/*
Copyright 2022 CAcert Inc.
SPDX-License-Identifier: Apache-2.0

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package forms

import (
	"fmt"
	"strings"

	"git.cacert.org/cacert-boardvoting/internal/models"
	"git.cacert.org/cacert-boardvoting/internal/validator"
)

const (
	minimumTitleLength   = 3
	maximumTitleLength   = 200
	minimumContentLength = 3
	maximumContentLength = 8000

	minimumJustificationLen = 3

	threeDays  = 3
	oneWeek    = 7
	twoWeeks   = 14
	threeWeeks = 28
)

type Form interface {
	Validate() error
	Normalize()
}

func validateUserName(v *validator.Validator, name string, field string) {
	v.CheckField(validator.NotBlank(name), field, "This field cannot be blank")
}

func validateEmailAddress(v *validator.Validator, address string, field string) {
	v.CheckField(validator.NotBlank(address), field, "This field cannot be blank")
	v.CheckField(validator.IsEmail(address), field, "This field must be an email address")
}

func validateReasoning(v *validator.Validator, reasoning string, field string) {
	v.CheckField(validator.NotBlank(reasoning), field, "This field cannot be blank")
	v.CheckField(
		validator.MinChars(reasoning, minimumJustificationLen),
		field,
		fmt.Sprintf("This field must be at least %d characters long", minimumJustificationLen),
	)
}

func validateMotionTitle(v *validator.Validator, title string, field string) {
	v.CheckField(
		validator.NotBlank(title),
		field,
		"This field cannot be blank",
	)
	v.CheckField(
		validator.MinChars(title, minimumTitleLength),
		field,
		fmt.Sprintf("This field must be at least %d characters long", minimumTitleLength),
	)
	v.CheckField(
		validator.MaxChars(title, maximumTitleLength),
		field,
		fmt.Sprintf("This field must be at most %d characters long", maximumTitleLength),
	)
}

func validateMotionContent(v *validator.Validator, content string, field string) {
	v.CheckField(
		validator.NotBlank(content),
		field,
		"This field cannot be blank",
	)
	v.CheckField(
		validator.MinChars(content, minimumContentLength),
		field,
		fmt.Sprintf("This field must be at least %d characters long", minimumContentLength),
	)
	v.CheckField(
		validator.MaxChars(content, maximumContentLength),
		field,
		fmt.Sprintf("This field must be at most %d characters long", maximumContentLength),
	)
}

type EditMotionForm struct {
	Title               string           `form:"title"`
	Content             string           `form:"content"`
	Type                *models.VoteType `form:"type"`
	Due                 int              `form:"due"`
	validator.Validator `form:"-"`
}

func (f *EditMotionForm) Validate() error {
	validateMotionTitle(&f.Validator, f.Title, "title")
	validateMotionContent(&f.Validator, f.Content, "content")
	f.CheckField(validator.NotNil(f.Type), "type", "You must choose a valid vote type")

	f.CheckField(validator.PermittedInt(
		f.Due, threeDays, oneWeek, twoWeeks, threeWeeks), "due", "invalid duration choice",
	)

	return nil
}

func (f *EditMotionForm) Normalize() {
	f.Title = strings.TrimSpace(f.Title)
	f.Content = strings.TrimSpace(f.Content)
}

type DirectVoteForm struct {
	Choice *models.VoteChoice
}

func (f *DirectVoteForm) Validate() error { return nil }

func (f *DirectVoteForm) Normalize() {}

type ProxyVoteForm struct {
	Voter               *models.User       `form:"voter"`
	Choice              *models.VoteChoice `form:"choice"`
	Justification       string             `form:"justification"`
	Voters              []*models.User     `form:"-"`
	validator.Validator `form:"-"`
}

func (f *ProxyVoteForm) Validate() error {
	f.CheckField(validator.NotNil(f.Voter), "voter", "Please choose a valid voter")
	validateReasoning(&f.Validator, f.Justification, "justification")
	f.CheckField(validator.NotNil(f.Choice), "choice", "A choice has to be made")

	return nil
}

func (f *ProxyVoteForm) Normalize() {
	f.Justification = strings.TrimSpace(f.Justification)
}

type EditUserForm struct {
	User                *models.User   `form:"-"`
	MailAddresses       []string       `form:"-"`
	AllRoles            []*models.Role `form:"-"`
	Name                string         `form:"name"`
	Roles               []string       `form:"roles"`
	ReminderMail        string         `form:"reminder_mail"`
	Reasoning           string         `form:"reasoning"`
	validator.Validator `form:"-"`
}

func (f *EditUserForm) Validate() error {
	addresses, err := f.User.EmailAddresses()
	if err != nil {
		return fmt.Errorf("error while validating form: %w", err)
	}

	validateUserName(&f.Validator, f.Name, "name")

	f.CheckField(
		validator.NotBlank(f.ReminderMail),
		"reminder_mail",
		"Must choose a reminder mail address",
	)
	f.CheckField(
		validator.PermittedString(f.ReminderMail, addresses...),
		"reminder_mail",
		"Reminder mail must be one of the user's email addresses",
	)

	allRoleNames := make([]string, len(f.AllRoles))
	for i := range f.AllRoles {
		allRoleNames[i] = f.AllRoles[i].Name
	}

	f.CheckField(
		validator.PermittedStringSet(f.Roles, allRoleNames),
		"roles",
		fmt.Sprintf("Roles must only contain values from %s", strings.Join(allRoleNames, ", ")),
	)

	validateReasoning(&f.Validator, f.Reasoning, "reasoning")

	return nil
}

func (f *EditUserForm) Normalize() {
	f.Name = strings.TrimSpace(f.Name)
	f.Reasoning = strings.TrimSpace(f.Reasoning)
}

func (f *EditUserForm) UpdateUser(edit *models.User) {
	edit.Reminder.String = f.ReminderMail
	edit.Name = f.Name
}

type NewUserForm struct {
	Name                string `form:"name"`
	EmailAddress        string `form:"email_address"`
	Reasoning           string `form:"reasoning"`
	validator.Validator `form:"-"`
}

func (f *NewUserForm) Validate() error {
	validateUserName(&f.Validator, f.Name, "name")
	validateEmailAddress(&f.Validator, f.EmailAddress, "email_address")
	validateReasoning(&f.Validator, f.Reasoning, "reasoning")

	return nil
}

func (f *NewUserForm) Normalize() {
	f.Name = strings.TrimSpace(f.Name)
	f.EmailAddress = strings.TrimSpace(f.EmailAddress)
	f.Reasoning = strings.TrimSpace(f.Reasoning)
}

func (f *NewUserForm) FillUser() *models.User {
	return &models.User{Name: f.Name}
}

type DeleteUserForm struct {
	User                *models.User `form:"user"`
	Reasoning           string       `form:"reasoning"`
	validator.Validator `form:"-"`
}

func (f *DeleteUserForm) Validate() error {
	validateReasoning(&f.Validator, f.Reasoning, "reasoning")

	return nil
}

func (f *DeleteUserForm) Normalize() {
	f.Reasoning = strings.TrimSpace(f.Reasoning)
}

type AddEmailForm struct {
	EmailAddress        string       `form:"email_address"`
	Reasoning           string       `form:"reasoning"`
	User                *models.User `form:"-"`
	EmailAddresses      []string     `form:"-"`
	validator.Validator `form:"-"`
}

func (f *AddEmailForm) Validate() error {
	validateEmailAddress(&f.Validator, f.EmailAddress, "email_address")
	validateReasoning(&f.Validator, f.Reasoning, "reasoning")

	return nil
}

func (f *AddEmailForm) Normalize() {
	f.EmailAddress = strings.TrimSpace(f.EmailAddress)
	f.Reasoning = strings.TrimSpace(f.Reasoning)
}

type DeleteEmailForm struct {
	EmailAddress        string       `form:"-"`
	User                *models.User `form:"-"`
	Reasoning           string       `form:"reasoning"`
	validator.Validator `form:"-"`
}

func (f *DeleteEmailForm) Validate() error {
	validateReasoning(&f.Validator, f.Reasoning, "reasoning")

	return nil
}

func (f *DeleteEmailForm) Normalize() {
	f.Reasoning = strings.TrimSpace(f.Reasoning)
}

type ChooseVoterForm struct {
	Reasoning           string  `form:"reasoning"`
	VoterIDs            []int64 `form:"voters"`
	Users               []*models.User
	validator.Validator `form:"-"`
}

func (f *ChooseVoterForm) Validate() error {
	validateReasoning(&f.Validator, f.Reasoning, "reasoning")

	return nil
}

func (f *ChooseVoterForm) Normalize() {
}