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.CompanyId, &employee.EmployeeInfo.Uid, &employee.EmployeeInfo.EmployeeName, &employee.EmployeeInfo.EmployeeAccount, &employee.SuMoney, &employee.Status),
			"INSERT INTO employees (id, company_id, uid, employee_name, employee_account, su_money, status) VALUES (?, ?, ?, ?, ?, ?, ?) RETURNING id, company_id, uid, employee_name, employee_account, su_money, status",
			employee.EmployeeId, employee.CompanyId, employee.EmployeeInfo.Uid, employee.EmployeeInfo.EmployeeName, employee.EmployeeInfo.EmployeeAccount, employee.SuMoney, employee.Status); err != nil {
			return employee, err
		}
	} else {
		if _, err := tx.QueryOne(
			pg.Scan(&employee.EmployeeId, &employee.CompanyId, &employee.EmployeeInfo.Uid, &employee.EmployeeInfo.EmployeeName, &employee.EmployeeInfo.EmployeeAccount, &employee.SuMoney, &employee.Status),
			"UPDATE employees SET employee_name=?, employee_account=?, su_money=?, status=? WHERE uid=? RETURNING id, company_id, uid, employee_name, employee_account, su_money, status",
			employee.EmployeeInfo.EmployeeName, employee.EmployeeInfo.EmployeeAccount, employee.SuMoney, employee.Status, 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.First(); err != nil {
		if err.Error() == "pg: no rows in result set" {
			return nil, fmt.Errorf("没有此资源")
		} else {
			return nil, err
		}
	}
	if employeeModel.Id == 0 {
		return nil, nil
	} else {
		return repository.transformPgModelToDomainModel(employeeModel)
	}
}

func (repository *EmployeeRepository) Find(queryOptions map[string]interface{}) (int64, []*domain.Employee, error) {
	tx := repository.transactionContext.PgTx
	var employeeModels []*models.Employee
	employees := make([]*domain.Employee, 0)
	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, employees, err
	} else {
		for _, employeeModel := range employeeModels {
			if employee, err := repository.transformPgModelToDomainModel(employeeModel); err != nil {
				return 0, employees, err
			} else {
				employees = append(employees, employee)
			}
		}
		return int64(count), employees, nil
	}
}

func (repository *EmployeeRepository) transformPgModelToDomainModel(employeeModel *models.Employee) (*domain.Employee, error) {
	return &domain.Employee{
		EmployeeId: employeeModel.Id,
		CompanyId:  employeeModel.CompanyId,
		EmployeeInfo: &domain.EmployeeInfo{
			Uid:             employeeModel.Uid,
			EmployeeName:    employeeModel.EmployeeName,
			EmployeeAccount: employeeModel.EmployeeAccount,
		},
		SuMoney: employeeModel.SuMoney,
		Status:  employeeModel.Status,
	}, nil
}

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