package handlers

import (
	database "app/database"
	"app/models"
	"app/repositories"
	"app/utils"
	"net/http"
	"strconv"

	"fmt"

	"github.com/labstack/echo/v4"
)

func initUser() *repositories.User_repository {
	db := database.Db()
	userRepository := new(repositories.User_repository)
	userRepository.DB = &db

	return userRepository
}

// RegisterUser godoc
// @Summary      Register User
// @Description  Send UserModel
// @Tags         register
// @Accept       json
// @Produce      json
// @Param		 user body models.User true "User Model"
// @Success      200  {object}  models.User
// @Failure      400
// @Router       /users/ [post]
func RegisterUser(c echo.Context) error {

	user := new(models.User)
	db := database.Db()
	if err := c.Bind(user); err != nil {
		return err
	}

	userRepository := initUser()
	user.Role = "user"
	err := userRepository.Create(user)
	if err != nil {
		return err
	}

	tempUser, err := utils.GetByPhoneNumber(user.CellPhone_number)
	if err != nil {
		return err
	}
	cartRepository := new(repositories.Carts_repository)
	cartRepository.DB = &db
	cart := new(models.Carts)
	cart.User_id = tempUser.User_id
	err = cartRepository.Create(cart)
	if err != nil {
		return err
	}

	//utils.GenerateToken(c,*user)

	return c.JSON(http.StatusCreated, user)
}

func GetSameUserNames(c echo.Context) error {
	username := c.Param("name")
	userRepository := initUser()

	users, err := userRepository.GetByName(username)
	if err != nil {
		return err
	}

	return c.JSON(http.StatusAccepted, users)

}

func GetUserByID(c echo.Context) error {
	id, err := strconv.Atoi(c.Param("id"))
	if err != nil {
		panic(err)
	}

	userRepository := initUser()

	user, err := userRepository.GetByID(uint(id))
	if err != nil {
		panic(err)
	}

	return c.JSON(http.StatusAccepted, user)
}

// UpdateUserName(name string, id uint) error
// UpdateEmail(email string, id uint) error
// UpdatePassword(password string, id uint) error
// UpdateRole(newRole string, id uint) error
// UpdateNationalCode(newCode string, id uint) error
// UpdateBirthDay(newBirthDay string, id uint) error
// UpdateFirstName(firstName string, id uint) error
// UpdateLastName(lastName string, id uint) error
// UpdatePostCode(newPostCode string, id uint) error
// Delete(name string, id uint) error

func UpdateUserName(c echo.Context) error {

	id, err := strconv.Atoi(c.Param("id"))
	if err != nil {
		fmt.Println(err)
	}

	var update struct {
		NewUsername string `json:"username"`
	}

	if err := c.Bind(&update); err != nil {
		panic(err)
	}

	userRepository := initUser()

	err = userRepository.UpdateUserName(update.NewUsername, uint(id))
	if err != nil {
		panic(err)
	}

	return c.String(http.StatusAccepted, "updated")
}

func UpdateEmail(c echo.Context) error {

	id, err := strconv.Atoi(c.Param("id"))
	if err != nil {
		fmt.Println(err)
	}

	var update struct {
		NewEmail string `json:"email"`
	}

	if err := c.Bind(&update); err != nil {
		panic(err)
	}

	userRepository := initUser()

	if update.NewEmail != "" {
		err = userRepository.UpdateEmail(update.NewEmail, uint(id))
		if err != nil {
			panic(err)
		}
	}

	return c.String(http.StatusAccepted, "updated")
}

func UpdatePassword(c echo.Context) error {

	id, err := strconv.Atoi(c.Param("id"))
	if err != nil {
		fmt.Println(err)
	}

	isNull := true

	var update struct {
		OldPassword string `json:"oldpassword"`
		NewPassword string `json:"password"`
	}

	if err := c.Bind(&update); err != nil {
		panic(err)
	}

	userRepository := initUser()

	user, err := userRepository.GetByID(uint(id))
	if err != nil {
		return err
	}

	if user.Password != "" {
		isNull = false
	}

	if isNull {
		password, err := utils.HashPW(update.NewPassword)
		if err != nil {
			return err
		}
		err = userRepository.UpdatePassword(password, uint(id))
		if err != nil {
			panic(err)
		}
	} else {
		checkpw, err := utils.Match(update.OldPassword, user.Email)
		if err != nil {
			return err
		}

		if checkpw {
			password, err := utils.HashPW(update.NewPassword)
			if err != nil {
				return err
			}
			err = userRepository.UpdatePassword(password, uint(id))
			if err != nil {
				panic(err)
			}
		}

	}

	return c.String(http.StatusAccepted, "updated")
}

func UpdateRole(c echo.Context) error {

	id, err := strconv.Atoi(c.Param("id"))
	if err != nil {
		panic(err)
	}

	var update struct {
		NewRole string `json:"role"`
	}

	if err := c.Bind(&update); err != nil {
		panic(err)
	}

	userRepository := initUser()

	if update.NewRole != "" {
		err = userRepository.UpdateRole(update.NewRole, uint(id))
		if err != nil {
			panic(err)
		}
	}

	return c.String(http.StatusAccepted, "updated")
}

func UpdateNationalCode(c echo.Context) error {

	id, err := strconv.Atoi(c.Param("id"))
	if err != nil {
		fmt.Println(err)
	}

	var update struct {
		NewNationalCode string `json:"national_code"`
	}

	if err := c.Bind(&update); err != nil {
		panic(err)
	}

	userRepository := initUser()

	if update.NewNationalCode != "" {
		err = userRepository.UpdateNationalCode(update.NewNationalCode, uint(id))
		if err != nil {
			panic(err)
		}
	}

	return c.String(http.StatusAccepted, "updated")
}

func UpdateBirthDay(c echo.Context) error {

	id, err := strconv.Atoi(c.Param("id"))
	if err != nil {
		fmt.Println(err)
	}

	var update struct {
		NewBirthDay string `json:"birthday"`
	}

	if err := c.Bind(&update); err != nil {
		panic(err)
	}

	userRepository := initUser()

	if update.NewBirthDay != "" {
		err = userRepository.UpdateBirthDay(update.NewBirthDay, uint(id))
		if err != nil {
			panic(err)
		}
	}

	return c.String(http.StatusAccepted, "updated")
}

func UpdateFirstName(c echo.Context) error {

	id, err := strconv.Atoi(c.Param("id"))
	if err != nil {
		fmt.Println(err)
	}

	var update struct {
		NewFirstName string `json:"firstname"`
	}

	if err := c.Bind(&update); err != nil {
		panic(err)
	}

	userRepository := initUser()

	if update.NewFirstName != "" {
		err = userRepository.UpdateFirstName(update.NewFirstName, uint(id))
		if err != nil {
			panic(err)
		}
	}

	return c.String(http.StatusAccepted, "updated")
}

func UpdateLastName(c echo.Context) error {

	id, err := strconv.Atoi(c.Param("id"))
	if err != nil {
		fmt.Println(err)
	}

	var update struct {
		NewLastName string `json:"lastname"`
	}

	if err := c.Bind(&update); err != nil {
		panic(err)
	}

	userRepository := initUser()

	if update.NewLastName != "" {
		err = userRepository.UpdateLastName(update.NewLastName, uint(id))
		if err != nil {
			panic(err)
		}
	}

	return c.String(http.StatusAccepted, "updated")
}

func DeleteUser(c echo.Context) error {
	id, err := strconv.Atoi(c.Param("id"))
	if err != nil {
		fmt.Println(err)
	}

	userRepository := initUser()

	err = userRepository.Delete(uint(id))
	if err != nil {
		panic(err)
	}

	return c.String(http.StatusAccepted, "removed")
}