package employee_service

import (
	"encoding/json"
	"errors"
	"github.com/go-pripro/shop/models"
	"github.com/go-pripro/shop/pkg/gredis"
	"github.com/go-pripro/shop/pkg/logging"
	"github.com/go-pripro/shop/service/cache_service"
	"golang.org/x/crypto/bcrypt"
)

type Employee struct {
	ID         int
	CreatedOn  int
	ModifiedOn int
	DeletedOn  int
	AvatarUrl  string
	Username   string
	Password   string
	Department string
	Position   string
	State      int

	PageNum  int
	PageSize int
}

func (syncEmployee *Employee) EncodePassword(password string) string {
	if hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost); err == nil {
		return string(hash)
	}
	return string(rune(0))
}

func (syncEmployee *Employee) Add() error {
	encodePassword := syncEmployee.EncodePassword(syncEmployee.Password)
	employee := map[string]interface{}{
		"avatar_url": syncEmployee.AvatarUrl,
		"username":   syncEmployee.Username,
		"password":   encodePassword,
		"department": syncEmployee.Department,
		"position":   syncEmployee.Position,
		"state":      syncEmployee.State,
	}

	if err := models.AddEmployee(employee); err != nil {
		return err
	}

	return nil
}

func (syncEmployee *Employee) Edit() error {
	encodePassword := syncEmployee.EncodePassword(syncEmployee.Password)

	return models.EditEmployee(syncEmployee.ID, map[string]interface{}{
		"avatar_url": syncEmployee.AvatarUrl,
		"username":   syncEmployee.Username,
		"password":   encodePassword,
		"department": syncEmployee.Department,
		"position":   syncEmployee.Position,
		"state":      syncEmployee.State,
	})
}

func (syncEmployee *Employee) Get() (*models.Employee, error) {
	var cacheEmployee *models.Employee

	cache := cache_service.Employee{
		ID: syncEmployee.ID,
	}
	key := cache.GetEmployeeKey()
	if gredis.Exists(key) {
		data, err := gredis.Get(key)
		if err != nil {
			logging.Info(err)
			return cacheEmployee, errors.New("从缓存中获取员工信息失败")
		} else {
			json.Unmarshal(data, &cacheEmployee)
			return cacheEmployee, nil
		}
	}

	if employee, err := models.GetEmployee(syncEmployee.ID); err != nil {
		return nil, err
	} else {
		gredis.Set(key, employee, 3600)
		return employee, nil

	}
}

func (syncEmployee *Employee) GetAll() ([]*models.Employee, error) {
	var (
		employees, cacheEmployees []*models.Employee
	)

	cache := cache_service.Employee{
		State:    syncEmployee.State,
		PageNum:  syncEmployee.PageNum,
		PageSize: syncEmployee.PageSize,
	}
	key := cache.GetEmployeesKey()
	if gredis.Exists(key) {
		data, err := gredis.Get(key)
		if err != nil {
			logging.Info(err)
		} else {
			json.Unmarshal(data, &cacheEmployees)
			return cacheEmployees, nil
		}
	}

	employees, err := models.GetEmployees(syncEmployee.PageNum, syncEmployee.PageSize, syncEmployee.getMaps())
	if err != nil {
		return nil, err
	}

	gredis.Set(key, employees, 3600)
	return employees, nil
}

func (syncEmployee *Employee) Delete() error {
	return models.DeleteEmployee(syncEmployee.ID)
}

func (syncEmployee *Employee) ExistByID() (bool, error) {
	return models.ExistEmployeeByID(syncEmployee.ID)
}

func (syncEmployee *Employee) Count() (int, error) {
	return models.GetEmployeeTotal(syncEmployee.getMaps())
}

func (syncEmployee *Employee) getMaps() map[string]interface{} {
	maps := make(map[string]interface{})
	maps["deleted_on"] = 0
	if syncEmployee.State != -1 {
		maps["state"] = syncEmployee.State
	}

	return maps
}