package repository

import (
	"fmt"
	"time"

	"github.com/go-pg/pg/v10"
	pgTransaction "github.com/linmadan/egglib-go/transaction/pg"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/infrastructure/pg/models"
)

type RewardSummaryRepository struct {
	transactionContext *pgTransaction.TransactionContext
}

var _ domain.RewardSummaryRepository = (*RewardSummaryRepository)(nil)

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

func (repo *RewardSummaryRepository) Save(param *domain.RewardSummary) (*domain.RewardSummary, error) {
	m := models.RewardSummary{
		Id:              param.Id,
		CompanyId:       param.CompanyId,
		OrgId:           param.OrgId,
		RecordDate:      param.RecordDate,
		RecordDateStr:   param.RecordDateStr,
		WorkStation:     param.WorkStation,
		Worker:          param.Worker,
		UpToStandard:    param.UpToStandard,
		Yield:           param.Yield,
		AccidentNum1:    param.AccidentNum1,
		AccidentAmount1: param.AccidentAmount1,
		AccidentNum2:    param.AccidentNum2,
		AccidentAmount2: param.AccidentAmount2,
		AccidentNum3:    param.AccidentNum3,
		AccidentNum4:    param.AccidentNum4,
		CreatedAt:       param.CreatedAt,
		UpdatedAt:       param.UpdatedAt,
		SummaryResult:   param.SummaryResult,
	}
	tx := repo.transactionContext.PgTx
	if param.Id == 0 {
		_, err := tx.Model(&m).Insert()
		if err != nil {
			return nil, err
		}
		param.Id = m.Id
	} else {
		_, err := tx.Model(&m).WherePK().Update()
		if err != nil {
			return nil, err
		}
	}

	return param, nil
}

func (repo *RewardSummaryRepository) FindOne(queryOptions map[string]interface{}) (*domain.RewardSummary, error) {
	tx := repo.transactionContext.PgTx
	m := new(models.RewardSummary)
	query := tx.Model(m)
	if v, ok := queryOptions["id"]; ok {
		query.Where("id=?", v)
	}
	err := query.First()
	if err != nil {
		if err == pg.ErrNoRows {
			return nil, domain.ErrorNotFound
		} else {
			return nil, err
		}
	}
	result := repo.TransformToDomain(m)
	return result, nil
}

func (repo *RewardSummaryRepository) Find(queryOptions map[string]interface{}) (int64, []*domain.RewardSummary, error) {
	tx := repo.transactionContext.PgTx
	m := []models.RewardSummary{}
	query := tx.Model(&m).
		Limit(20)
	if v, ok := queryOptions["limit"].(int); ok && v >= 0 {
		query.Limit(v)
	}
	if v, ok := queryOptions["offset"].(int); ok && v >= 0 {
		query.Offset(v)
	}
	if v, ok := queryOptions["companyId"]; ok {
		query.Where("company_id=?", v)
	}
	if v, ok := queryOptions["orgId"]; ok {
		query.Where("org_id=?", v)
	}
	//车间名称
	if v, ok := queryOptions["workshopName"]; ok && len(v.(string)) > 0 {
		query.Where(`Work_station->>'workshopName' like ?`, fmt.Sprintf("%%%v%%", v))
	}
	//线别名称
	if v, ok := queryOptions["lineName"]; ok && len(v.(string)) > 0 {
		query.Where(`Work_station->>'lineName' like ?`, fmt.Sprintf("%%%v%%", v))
	}
	//工段id
	if v, ok := queryOptions["sectionId"]; ok {
		query.Where(`Work_station->>'sectionId' = '?'`, v)
	}
	//车间id
	if v, ok := queryOptions["workshopId"]; ok {
		query.Where(`Work_station->>'workshopId'='?'`, v)
	}
	//线别id
	if v, ok := queryOptions["lineId"]; ok {
		query.Where(`Work_station->>'lineId' = '?'`, v)
	}
	//日期开始
	if v, ok := queryOptions["beginDate"]; ok {
		if !(v.(time.Time)).IsZero() {
			query.Where("record_date>=?", v)
		}
	}
	//日期结束
	if v, ok := queryOptions["endDate"]; ok {
		if !(v.(time.Time)).IsZero() {
			query.Where("record_date<=?", v)
		}
	}

	//指定查询某个日期
	if v, ok := queryOptions["recordDateStr"]; ok {
		query.Where("record_date_str=?", v)
	}
	cnt, err := query.SelectAndCount()
	if err != nil {
		return 0, nil, err
	}

	var listData []*domain.RewardSummary
	for i := range m {
		temp := repo.TransformToDomain(&m[i])
		listData = append(listData, temp)
	}
	return int64(cnt), listData, nil
}

func (repo *RewardSummaryRepository) TransformToDomain(param *models.RewardSummary) *domain.RewardSummary {
	return &domain.RewardSummary{
		Id:              param.Id,
		CompanyId:       param.CompanyId,
		OrgId:           param.OrgId,
		RecordDate:      param.RecordDate,
		WorkStation:     param.WorkStation,
		Worker:          param.Worker,
		UpToStandard:    param.UpToStandard,
		Yield:           param.Yield,
		AccidentNum1:    param.AccidentNum1,
		AccidentAmount1: param.AccidentAmount1,
		AccidentNum2:    param.AccidentNum2,
		AccidentAmount2: param.AccidentAmount2,
		AccidentNum3:    param.AccidentNum3,
		AccidentNum4:    param.AccidentNum4,
		CreatedAt:       param.CreatedAt,
		UpdatedAt:       param.UpdatedAt,
		SummaryResult:   param.SummaryResult,
		RecordDateStr:   param.RecordDateStr,
	}
}