// Validate the RegisterModel instance
func (vm RegisterViewModel) Validate(errors binding.Errors, req *http.Request) binding.Errors {
	vm.Account.Name = strings.TrimSpace(vm.Account.Name)
	vm.Account.ContactName = strings.TrimSpace(vm.Account.ContactName)
	vm.Account.ContactEmail = strings.TrimSpace(vm.Account.ContactEmail)
	vm.Account.ContactPhoneNumber = strings.TrimSpace(vm.Account.ContactPhoneNumber)
	vm.Account.Host = strings.TrimSpace(vm.Account.Host)

	if len(vm.Account.Host) > 20 {
		errors.Add([]string{"host"}, "", "The host must be smaller than 20 characters")
	}

	if len(vm.Account.Name) < 3 || len(vm.Account.Name) > 100 {
		errors.Add([]string{"name"}, "", "The account name must be at least 3 characters or smaller than 255")
	}

	if len(vm.Account.ContactName) < 3 {
		errors.Add([]string{"contact_name"}, "", "The contact name must be at least 3 characters or smaller than 255")
	}

	if len(vm.Account.ContactPhoneNumber) < 10 || len(vm.Account.ContactPhoneNumber) > 50 {
		errors.Add([]string{"contact_phone_number"}, "", "A valid phone number must be provided")
	}

	_, err := mail.ParseAddress(vm.Account.ContactEmail)
	if len(vm.Account.ContactEmail) < 3 || err != nil {
		errors.Add([]string{"email"}, "", "A valid email address must be provided")
	}

	return errors
}

func adminErrorHandler(err binding.Errors, w http.ResponseWriter) {
	if err.Len() > 0 {
		e := err[0]
		s := e.Classification + ": "
		if len(e.FieldNames) > 0 {
			s += strings.Join(e.FieldNames, ",")
		}
		s += " " + e.Message
		writeResponse(w, errors.NewError(errors.JsonError, s))
	}
}

func CreateBlog(r render.Render, err binding.Errors, post models.Post, data middleware.Data) {
	if err.Count() > 0 {
		data["errors"] = err
		r.HTML(200, "blogs/new", data)
		return
	}
	if e := models.CreateNewPost(&post); e != nil {
		log.Println(err)
	}
	r.Redirect("/")
}

func ErrorHandler(err binding.Errors, request *http.Request, resp http.ResponseWriter) {
	if err.Len() > 0 {
		e := err[0]
		s := e.Classification + ": "
		if len(e.FieldNames) > 0 {
			s += strings.Join(e.FieldNames, ",")
		}
		s += " " + e.Message
		writeResponse(request.RequestURI, resp, nil, errors.NewError(errors.JsonError, s))
	}
}

func CreateDevice(r render.Render, err binding.Errors, device models.Device, data middleware.Data, req *http.Request) {
	if err.Len() > 0 {
		data["errors"] = err
		r.HTML(http.StatusBadRequest, "devices/new", data)
		return
	}
	if e := models.AddDevice(&device); e != nil {
		data["errors"] = updateError(err, e)
		r.HTML(http.StatusBadRequest, "devices/new", data)
		return
	}
	websocketClient(req.Host, device)
	r.Redirect("/devices")
}

func (srv *httpServer) createAppEvents(evt Event, err binding.Errors, resp http.ResponseWriter, req *http.Request) string {
	if err.Count() > 0 {
		resp.WriteHeader(http.StatusBadRequest)
		return fmt.Sprintf(`{"errors":"%v"}`, err)
	}
	socketID := req.URL.Query().Get("socket_id")
	log.Printf("received event: %#v\n", evt)
	for _, payload := range evt.Payloads(socketID) {
		_, pubErr := srv.h.PublishEvent(payload)
		if pubErr != nil {
			log.Printf("ERROR: %v\n", pubErr)
			resp.WriteHeader(http.StatusInternalServerError)
			return `{}`
		}
	}
	resp.WriteHeader(http.StatusAccepted)
	return `{}`
}

// AccountSave renders user's account page
func AccountSave(r render.Render, tokens oauth2.Tokens, session sessions.Session, username UsernameForm, err binding.Errors) {
	pd := NewPageData(tokens, session)

	if len(username.Username) > 0 {
		existingUser := &User{Username: username.Username}
		db.Where(existingUser).First(existingUser)

		if existingUser.ID > 0 {
			err.Add([]string{"username"}, "RequiredError", "This username is already taken.")
		}

		log.Printf("[AccountSave] existing user: %s", existingUser)
	}

	if err.Len() == 0 {
		user := pd.User
		if user.Username != username.Username {
			path := filepath.Join(HomeDir(), "app/public/files/"+user.Username)
			if len(user.Username) == 0 {
				path = filepath.Join(HomeDir(), "app/public/files/"+username.Username)
			}
			if _, err := os.Stat(path); os.IsNotExist(err) || len(user.Username) == 0 {
				os.Mkdir(path, 0755)
			}
			if _, err := os.Stat(path); err == nil {
				newPath := filepath.Join(HomeDir(), "app/public/files/"+username.Username)
				os.Rename(path, newPath)
			}
			user.Username = username.Username
			db.Save(user)
		}
		session.AddFlash("You have successfully updated your BareCV username / domain.", "success")
		r.Redirect(config.AppUrl+"/account", 302)
	} else {
		pd.Errors = &err
		log.Printf("[AccountSave] errors: %s", err[0].Classification)
		r.HTML(200, "account", pd)
	}
}

// Save saves dashboard page
func Save(r render.Render, tokens oauth2.Tokens, session sessions.Session, profile ProfileForm, err binding.Errors) {
	pd := NewPageData(tokens, session)

	log.Printf("[Save] profile: %s", profile)

	if err.Len() == 0 {
		user := pd.User
		user.Name = profile.Name
		user.Profession = profile.Profession
		user.Email = profile.Email
		user.Phone = profile.Phone
		user.Website = profile.Website
		user.Address = profile.Address
		db.Save(user)
		session.AddFlash("You have successfully updated your BareCV profile.", "success")
		r.Redirect(config.AppUrl+"/cv", 302)
	} else {
		pd.Errors = &err
		log.Printf("[Save] errors: %s", err[0].FieldNames)
		r.HTML(200, "cv", pd)
	}
}