package repository

import (
	"fmt"
	"github.com/go-pg/pg"
	pgTransaction "github.com/linmadan/egglib-go/transaction/pg"
	"github.com/linmadan/egglib-go/utils/snowflake"
	"gitlab.fjmaimaimai.com/linmadan/mmm-worth/pkg/domain"
	"gitlab.fjmaimaimai.com/linmadan/mmm-worth/pkg/infrastructure/pg/models"
)

type EmployeeRepository struct {
	transactionContext *pgTransaction.TransactionContext
}

func (repository *EmployeeRepository) nextIdentify() (int64, error) {
	IdWorker, err := snowflake.NewIdWorker(1)
	if err != nil {
		return 0, err
	}
	id, err := IdWorker.NextId()
	return id, err
}

func (repository *EmployeeRepository) Save(employee *domain.Employee) (*domain.Employee, error) {
	tx := repository.transactionContext.PgTx
	if employee.Identify() == nil {
		_, err := repository.nextIdentify()
		if err != nil {
			return employee, err
		}
		if _, err := tx.QueryOne(
			pg.Scan(&employee.EmployeeId, &employee.EmployeeInfo.Uid, &employee.EmployeeInfo.EmployeeName, &employee.EmployeeInfo.EmployeeAccount, &employee.SuMoney),
			"INSERT INTO employees (id, uid, employee_name, employee_account, su_money) VALUES (?, ?, ?, ?, ?) RETURNING id, uid, employee_name, employee_account, su_money",
			employee.EmployeeId, employee.EmployeeInfo.Uid, employee.EmployeeInfo.EmployeeName, employee.EmployeeInfo.EmployeeAccount, employee.SuMoney); err != nil {
			return employee, err
		}
	} else {
		if _, err := tx.QueryOne(
			pg.Scan(&employee.EmployeeId, &employee.EmployeeInfo.Uid, &employee.EmployeeInfo.EmployeeName, &employee.EmployeeInfo.EmployeeAccount, &employee.SuMoney),
			"UPDATE employees SET employee_name=?, employee_account=?, su_money=? WHERE uid=? RETURNING id, uid, employee_name, employee_account, su_money",
			employee.EmployeeInfo.EmployeeName, employee.EmployeeInfo.EmployeeAccount, employee.SuMoney, employee.EmployeeInfo.Uid); err != nil {
			return employee, err
		}
	}
	return employee, nil
}

func (repository *EmployeeRepository) Remove(employee *domain.Employee) (*domain.Employee, error) {
	tx := repository.transactionContext.PgTx
	employeeModel := new(models.Employee)
	employeeModel.Id = employee.Identify().(int64)
	if _, err := tx.Model(employeeModel).Where("uid = ?", employee.EmployeeInfo.Uid).Delete(); err != nil {
		return employee, err
	}
	return employee, nil
}

func (repository *EmployeeRepository) FindOne(queryOptions map[string]interface{}) (*domain.Employee, error) {
	tx := repository.transactionContext.PgTx
	employeeModel := new(models.Employee)
	query := tx.Model(employeeModel)
	if uid, ok := queryOptions["uid"]; ok {
		query = query.Where("employee.uid = ?", uid)
	}
	if err := query.Limit(1).Select(); err != nil {
		return nil, err
	}
	if employeeModel.Id == 0 {
		return nil, nil
	} else {
		return &domain.Employee{
			EmployeeId: employeeModel.Id,
			EmployeeInfo: &domain.EmployeeInfo{
				Uid:             employeeModel.Uid,
				EmployeeName:    employeeModel.EmployeeName,
				EmployeeAccount: employeeModel.EmployeeAccount,
			},
			SuMoney: employeeModel.SuMoney,
		}, nil
	}
}

func (repository *EmployeeRepository) Find(queryOptions map[string]interface{}) (int64, []*domain.Employee, error) {
	tx := repository.transactionContext.PgTx
	var employeeModels []*models.Employee
	var employees []*domain.Employee
	query := tx.Model(&employeeModels)
	if offset, ok := queryOptions["offset"]; ok {
		offset := offset.(int)
		if offset > -1 {
			query = query.Offset(offset)
		}
	} else {
		query = query.Offset(0)
	}
	if limit, ok := queryOptions["limit"]; ok {
		limit := limit.(int)
		if limit > -1 {
			query = query.Limit(limit)
		}
	} else {
		query = query.Limit(20)
	}
	if count, err := query.Order("uid DESC").SelectAndCount(); err != nil {
		return 0, nil, err
	} else {
		for _, employeeModel := range employeeModels {
			employees = append(employees, &domain.Employee{
				EmployeeId: employeeModel.Id,
				EmployeeInfo: &domain.EmployeeInfo{
					Uid:             employeeModel.Uid,
					EmployeeName:    employeeModel.EmployeeName,
					EmployeeAccount: employeeModel.EmployeeAccount,
				},
				SuMoney: employeeModel.SuMoney,
			})
		}
		return int64(count), employees, nil
	}
}

func NewEmployeeRepository(transactionContext *pgTransaction.TransactionContext) (*EmployeeRepository, error) {
	if transactionContext == nil {
		return nil, fmt.Errorf("transactionContext参数不能为nil")
	} else {
		return &EmployeeRepository{
			transactionContext: transactionContext,
		}, nil
	}
}