package entity

import (
	"furtuna-be/internal/constants/role"
	"furtuna-be/internal/constants/userstatus"
	"time"
)

type AuthData struct {
	Token          string `json:"token"`
	UserID         int64  `gorm:"column:user_id"`
	RoleID         int    `gorm:"column:role_id"`
	OrganizationID int64  `gorm:"column:organization_id"`
}

type UserDB struct {
	ID          int64                 `gorm:"primary_key;column:id" json:"id"`
	Name        string                `gorm:"column:name" json:"name"`
	Email       string                `gorm:"column:email" json:"email"`
	Password    string                `gorm:"column:password" json:"-"`
	Status      userstatus.UserStatus `gorm:"column:status" json:"status"`
	UserType    string                `gorm:"column:user_type" json:"user_type"`
	PhoneNumber string                `gorm:"column:phone_number" json:"phone_number"`
	NIK         string                `gorm:"column:nik" json:"nik"`
	RoleID      int64                 `gorm:"column:role_id" json:"role_id"`
	RoleName    string                `gorm:"column:role_name" json:"role_name"`
	BranchID    *int64                `gorm:"column:partner_id" json:"partner_id"`
	BranchName  string                `gorm:"column:partner_name" json:"partner_name"`
	CreatedAt   time.Time             `gorm:"column:created_at" json:"created_at"`
	UpdatedAt   time.Time             `gorm:"column:updated_at" json:"updated_at"`
	DeletedAt   *time.Time            `gorm:"column:deleted_at" json:"deleted_at"`
	CreatedBy   int64                 `gorm:"column:created_by" json:"created_by"`
	UpdatedBy   int64                 `gorm:"column:updated_by" json:"updated_by"`
}

func (u *UserDB) ToUser() *User {
	if u == nil {
		return &User{}
	}

	userEntity := &User{
		ID:         u.ID,
		Name:       u.Name,
		Email:      u.Email,
		Status:     u.Status,
		CreatedAt:  u.CreatedAt,
		UpdatedAt:  u.UpdatedAt,
		RoleID:     role.Role(u.RoleID),
		RoleName:   u.RoleName,
		PartnerID:  u.BranchID,
		BranchName: u.BranchName,
	}

	return userEntity
}

func (u *UserDB) ToUserRoleDB() *UserRoleDB {
	if u == nil {
		return &UserRoleDB{}
	}

	userRole := &UserRoleDB{
		ID:        0,
		UserID:    u.ID,
		RoleID:    u.RoleID,
		PartnerID: u.BranchID,
		CreatedAt: u.CreatedAt,
		UpdatedAt: u.UpdatedAt,
	}

	return userRole
}

func (UserDB) TableName() string {
	return "users"
}

func (u *UserDB) ToUserAuthenticate(signedToken string) *AuthenticateUser {
	return &AuthenticateUser{
		Token:      signedToken,
		Name:       u.Name,
		RoleID:     role.Role(u.RoleID),
		RoleName:   u.RoleName,
		BranchID:   u.BranchID,
		BranchName: u.BranchName,
	}
}

type UserSearch struct {
	Search    string
	Name      string
	RoleID    int64
	PartnerID int64
	Limit     int
	Offset    int
}

type UserList []*UserDB

func (b *UserList) ToUserList() []*User {
	var users []*User
	for _, user := range *b {
		users = append(users, user.ToUser())
	}
	return users
}

func (u *UserDB) ToUpdatedUser(req User) error {

	if req.Name != "" {
		u.Name = req.Name
	}

	if req.Email != "" {
		u.Email = req.Email
	}

	if *req.PartnerID > 0 {
		u.BranchID = req.PartnerID
	}

	if req.RoleID > 0 {
		u.RoleID = int64(req.RoleID)
	}

	if req.Password != "" {
		hashedPassword, err := req.HashedPassword(req.Password)

		if err != nil {
			return err
		}
		u.Password = hashedPassword
	}

	return nil
}

func (o *UserDB) SetDeleted(updatedby int64) {
	currentTime := time.Now()
	o.DeletedAt = &currentTime
	o.UpdatedBy = updatedby
	o.Status = userstatus.Inactive
}