package service

import (
	"github.com/shopspring/decimal"
	"time"
	"wms/constvar"
	"wms/models"
	"wms/pkg/logx"
	"wms/request"
	"wms/utils"
)

type WarehouseMonthFormsService struct{}

func NewWarehouseMonthFormsService() *WarehouseMonthFormsService {
	return &WarehouseMonthFormsService{}
}

func (slf *WarehouseMonthFormsService) Query(params request.GetMonthStats) (result []*models.WarehouseMonthStats, err error) {
	search := slf.BuildSearch(params)
	search = search.SetPage(params.Page, params.PageSize)
	return search.FindNotTotal()
}

func (slf *WarehouseMonthFormsService) BuildSearch(params request.GetMonthStats) (search *models.WarehouseMonthStatsSearch) {
	search = models.NewWarehouseMonthStatsSearch().SetKeyword(params.Keyword).SetDate(params.Date)
	if params.Preload {
		search = search.SetPreload(true)
	}
	return search
}

func (slf *WarehouseMonthFormsService) Count(params request.GetMonthStats) (total int64, err error) {
	search := slf.BuildSearch(params)
	return search.Count()
}

func (slf *WarehouseMonthFormsService) FetchAll(params request.GetMonthStats) (list []*models.WarehouseMonthStats, err error) {
	total, err := slf.Count(params)
	if err != nil {
		return nil, err
	}
	list = make([]*models.WarehouseMonthStats, 0, total)
	params.PageSize = 500
	page := 1
	for {
		params.Page = page
		data, err := slf.Query(params)
		if err != nil {
			return nil, err
		}
		if len(data) == 0 {
			break
		}
		list = append(list, data...)
		page++
	}
	return
}

func GetCurrentWarehouseStats(date string, warehouseId int, productIds []string) (statRecords []*models.WarehouseMonthStats, err error) {
	//本月期初数量/上月结余数量
	groupSumList, err := models.NewLocationProductAmountSearch().SetProductIds(productIds).GroupSum("product_id", "amount")
	productIds = make([]string, 0, len(groupSumList))
	for _, groupSum := range groupSumList {
		productIds = append(productIds, groupSum.Class)
	}
	products, err := models.NewMaterialSearch().SetFields("id, name, unit, weight, more_unit, more_unit_value").SetIDs(productIds).FindNotTotal()
	if err != nil {
		logx.Errorf("MonthStats GetCurrentStats get products err:%v", err)
		return
	}
	productMap := models.MaterialMap(products)

	beginTime, endTime := utils.GetLastMonthPeriod()
	inputMap, err := GetStatsMulti(beginTime, endTime, constvar.BaseOperationTypeIncoming, warehouseId)
	if err != nil {
		logx.Errorf("MonthStats GetStatsByOperationType input err:%v", err)
		return
	}

	outputMap, err := GetStatsMulti(beginTime, endTime, constvar.BaseOperationTypeOutgoing, warehouseId)
	if err != nil {
		logx.Errorf("MonthStats GetStatsByOperationType output err:%v", err)
		return
	}

	for _, groupSum := range groupSumList {
		productId := groupSum.Class
		if productMap[productId] == nil {
			continue
		}
		product := productMap[productId]

		amount := groupSum.Sum
		record := models.WarehouseMonthStats{
			WarehouseId:  warehouseId,
			ProductId:    productId,
			ProductName:  product.Name,
			Unit:         product.Unit,
			SalePrice:    product.SalePrice,
			EndAmount:    amount,
			InputAmount:  SumMapAmount(inputMap[productId]),
			InputItems:   GetDealerItems(inputMap[productId]),
			OutputAmount: SumMapAmount(outputMap[productId]),
			OutputItems:  GetDealerItems(outputMap[productId]),
			Date:         date,
		}
		statRecords = append(statRecords, &record)
	}

	return
}

func GetStatsMulti(beginTime, endTime time.Time, operationType constvar.BaseOperationType, warehouseId int) (m map[string]map[string]decimal.Decimal, err error) {
	operationIds, err := models.NewOperationSearch().SetBaseOperationType(operationType).
		SetFields("id").SetTimeBetween(beginTime, endTime).
		SetWarehouseId(warehouseId).
		FindIds()
	if err != nil {
		return
	}
	groupSumList, err := models.NewOperationDetailsSearch().SetOperationIds(operationIds).
		SetFields("product_id, dealer_type, amount").
		GroupMultiSumAmount()
	if err != nil {
		return
	}
	m = make(map[string]map[string]decimal.Decimal)
	for _, v := range groupSumList {
		if m[v.ProductID] == nil {
			m[v.ProductID] = make(map[string]decimal.Decimal)
		}
		m[v.ProductID][v.DealerType] = v.Sum
	}
	return
}

func SumMapAmount(m map[string]decimal.Decimal) (sum decimal.Decimal) {
	for _, v := range m {
		sum = sum.Add(v)
	}
	return
}

func GetDealerItems(m map[string]decimal.Decimal) (items []*models.WarehouseStatsItems) {
	for k, v := range m {
		items = append(items, &models.WarehouseStatsItems{
			Name:   k,
			Amount: v,
		})
	}
	return
}