package system

import (
	"context"
	"fmt"
	"time"

	"management/internal/erpserver/model/dto"
	"management/internal/erpserver/model/system"
	"management/internal/erpserver/repository"
	"management/internal/pkg/crypto"
	"management/internal/pkg/database"
	"management/internal/pkg/rand"

	"github.com/google/uuid"
)

type userRepository struct {
	repo *repository.Repository
}

func NewUserRepository(repo *repository.Repository) system.UserRepository {
	return &userRepository{
		repo: repo,
	}
}

func (s *userRepository) Initialize(ctx context.Context, departId, roleId int32) error {
	var count int64
	if err := s.repo.DB(ctx).Model(&system.User{}).Count(&count).Error; err != nil {
		return err
	}
	if count == 0 {
		salt, err := rand.String(10)
		if err != nil {
			return err
		}

		password := "secret"
		hashedPassword, err := crypto.BcryptHashPassword(password + salt)
		if err != nil {
			return err
		}

		initTime, err := time.ParseInLocation(time.DateTime, "0001-01-01 00:00:00", time.Local)
		if err != nil {
			return err
		}

		user := system.User{
			Uuid:             uuid.Must(uuid.NewV7()),
			Email:            "1185230223@qq.com",
			Username:         "kenneth",
			HashedPassword:   hashedPassword,
			Salt:             salt,
			Avatar:           "/statics/admin/images/avatar.jpg",
			Gender:           1,
			DepartmentID:     departId,
			RoleID:           roleId,
			Status:           0,
			ChangePasswordAt: initTime,
			CreatedAt:        time.Now(),
			UpdatedAt:        time.Now(),
		}
		return s.Create(ctx, &user)
	}

	return nil
}

func (s *userRepository) Create(ctx context.Context, obj *system.User) error {
	return s.repo.DB(ctx).Create(obj).Error
}

func (s *userRepository) Update(ctx context.Context, obj *system.User) error {
	return s.repo.DB(ctx).Save(obj).Error
}

func (s *userRepository) Get(ctx context.Context, id int32) (*system.User, error) {
	var user system.User
	err := s.repo.DB(ctx).Where("id = ?", id).First(&user).Error
	if err != nil {
		if database.IsNoRows(err) {
			return nil, fmt.Errorf("user %d not found: %w", id, err)
		}
		return nil, err
	}
	return &user, nil
}

func (s *userRepository) GetByEmail(ctx context.Context, email string) (*system.User, error) {
	var user system.User
	err := s.repo.DB(ctx).Where("email = ?", email).First(&user).Error
	if err != nil {
		if database.IsNoRows(err) {
			return nil, fmt.Errorf("user by email %s not found: %w", email, err)
		}
		return nil, err
	}
	return &user, nil
}

func (s *userRepository) All(ctx context.Context) ([]*system.User, error) {
	var users []*system.User
	err := s.repo.DB(ctx).Find(&users).Error
	if err != nil {
		return nil, err
	}
	return users, nil
}

func (s *userRepository) List(ctx context.Context, q dto.SearchDto) ([]*system.User, int64, error) {
	query := s.repo.DB(ctx).
		Model(&system.User{}).
		Preload("Role").
		Preload("Department").
		Where("created_at BETWEEN ? AND ?", q.SearchTimeBegin, q.SearchTimeEnd)
	if q.SearchID != 0 {
		query = query.Where("id = ?", q.SearchID)
	}
	if q.SearchName != "" {
		query = query.Where("username LIKE ?", "%"+q.SearchName+"%")
	}
	if q.SearchEmail != "" {
		query = query.Where("email LIKE ?", "%"+q.SearchEmail+"%")
	}
	if q.SearchStatus != 9999 {
		query = query.Where("status = ?", q.SearchStatus)
	}

	var count int64
	err := query.Count(&count).Error
	if err != nil {
		return nil, 0, err
	}

	var users []*system.User
	err = query.
		Order("id DESC").
		Offset((q.Page - 1) * q.Rows).
		Limit(q.Rows).
		Find(&users).Error
	if err != nil {
		return nil, 0, err
	}
	return users, count, nil
}