package report

import (
	"errors"
	"fmt"
	"math"
	"time"

	"git.rosy.net.cn/jx-callback/business/jxutils/tasksch"

	"git.rosy.net.cn/baseapi/utils"
	"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"
	"git.rosy.net.cn/jx-callback/business/model"
	"git.rosy.net.cn/jx-callback/business/model/dao"
)

type tStoreSkuBindAndSkuName struct {
	CityCode      int
	StoreID       int `orm:"column(store_id)"`
	NameID        int `orm:"column(name_id)"`
	UnitPrice     int
	UnitPriceList []int
}

func GetStatisticsReportForOrders(ctx *jxcontext.Context, storeIDs []int, fromDate string, toDate string) (statisticsReportForOrdersList []*dao.StatisticsReportForOrdersList, err error) {
	db := dao.GetDB()
	fromDateParm := utils.Str2Time(fromDate)
	toDateParm := utils.Str2Time(toDate)
	//若时间间隔大于3个月则不允许查询
	if math.Ceil(toDateParm.Sub(fromDateParm).Hours()/24) > 92 {
		return nil, errors.New(fmt.Sprintf("查询间隔时间不允许大于3个月！: 时间范围：[%v]  至  [%v]", fromDate, toDate))
	}
	statisticsReportForOrdersList, err = dao.GetStatisticsReportForOrders(db, storeIDs, fromDateParm, toDateParm)
	return statisticsReportForOrdersList, err
}

func GetStatisticsReportForAfsOrders(ctx *jxcontext.Context, storeIDs []int, fromDate string, toDate string) (statisticsReportForOrdersList []*dao.StatisticsReportForOrdersList, err error) {
	db := dao.GetDB()
	fromDateParm := utils.Str2Time(fromDate)
	toDateParm := utils.Str2Time(toDate)
	//若时间间隔大于3个月则不允许查询
	if math.Ceil(toDateParm.Sub(fromDateParm).Hours()/24) > 92 {
		return nil, errors.New(fmt.Sprintf("查询间隔时间不允许大于3个月！: 时间范围：[%v]  至  [%v]", fromDate, toDate))
	}
	statisticsReportForOrdersList, err = dao.GetGetStatisticsReportForAfsOrders(db, storeIDs, fromDateParm, toDateParm)
	return statisticsReportForOrdersList, err
}

func StatisticsReportForStoreSkusPrice(ctx *jxcontext.Context, cityCodes, skuIDs []int, snapDate string, offset, pageSize int) (pagedInfo *model.PagedInfo, err error) {
	var snapDateParam time.Time
	db := dao.GetDB()
	if snapDate != "" {
		snapDateParam = utils.Str2Time(snapDate)
	}
	priceReferSnapshot, totalCount, err := dao.GetPriceReferSnapshot(db, cityCodes, skuIDs, 0, snapDateParam, offset, pageSize)
	pagedInfo = &model.PagedInfo{
		Data:       priceReferSnapshot,
		TotalCount: totalCount,
	}
	return
}

func BeginSavePriceRefer(ctx *jxcontext.Context, cityCodes, skuIDs []int, isAsync, isContinueWhenError bool) (hint string, err error) {
	db := dao.GetDB()
	snapshotAt := utils.Time2Date(time.Now().AddDate(0, 0, -1))
	taskSeqFunc := func(task *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
		switch step {
		case 0:
			priceReferSnapshot, err := dao.GetStatisticsReportForStoreSkusPrice(db, cityCodes, skuIDs)
			if len(priceReferSnapshot) > 0 {
				dao.Begin(db)
				defer func() {
					if r := recover(); r != nil || err != nil {
						dao.Rollback(db)
						if r != nil {
							panic(r)
						}
					}
				}()
				dao.DeletePriceReferHistory(db, utils.Time2Date(snapshotAt.AddDate(0, 0, -7)))
				priceReferSnapshotDelete := &model.PriceReferSnapshot{SnapshotAt: snapshotAt}
				dao.DeleteEntity(db, priceReferSnapshotDelete, "SnapshotAt")
				taskFunc := func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
					v := batchItemList[0].(*model.PriceReferSnapshot)
					dao.WrapAddIDCULDEntity(v, ctx.GetUserName())
					v.SnapshotAt = snapshotAt
					err = dao.CreateEntity(db, v)
					return retVal, err
				}
				taskParallel := tasksch.NewParallelTask("生成价格统计", tasksch.NewParallelConfig(), ctx, taskFunc, priceReferSnapshot)
				tasksch.HandleTask(taskParallel, task, true).Run()
				_, err = taskParallel.GetResult(0)
				dao.Commit(db)
			}
		case 1:
			var (
				// citySkuMap = make(map[int]map[int][]int)
				tList []*tStoreSkuBindAndSkuName
			)
			storeList, err := dao.GetStoreList(db, nil, nil, "")
			if err != nil {
				return result, err
			}
			for _, v := range storeList {
				sql := `
				SELECT DISTINCT b.city_code,a.store_id,a.unit_price,c.name_id
				FROM store_sku_bind a
				JOIN store b ON b.id = a.store_id AND b.deleted_at = ? AND b.status != ?
				JOIN sku c ON c.id = a.sku_id
				WHERE a.store_id = ? 
				AND c.name_id NOT IN(
				SELECT b.name_id
							FROM store_sku_bind a
							JOIN sku b ON a.sku_id = b.id AND b.deleted_at = ?
							WHERE a.deleted_at = ?
							AND a.store_id = ?
							AND b.name_id NOT IN(SELECT DISTINCT b.name_id
												FROM store_sku_bind a
												JOIN sku b ON a.sku_id = b.id AND b.deleted_at = ?
												WHERE a.deleted_at = ?
												AND a.store_id = ?
												AND a.status = ?)
												)
				`
				sqlParams := []interface{}{
					utils.DefaultTimeValue,
					model.StoreStatusDisabled,
					v.ID,
					utils.DefaultTimeValue,
					utils.DefaultTimeValue,
					v.ID,
					utils.DefaultTimeValue,
					utils.DefaultTimeValue,
					v.ID,
					model.StoreSkuBindStatusNormal,
				}
				dao.GetRows(db, &tList, sql, sqlParams...)
				// for _, vv := range tList {
				// 	if citySkuMap[vv.CityCode] != nil {

				// 	} else {
				// 		citySkuMap[vv.CityCode] =
				// 	}
				// }
			}
		case 2:
			priceReferSnapshotList, err := dao.GetPriceReferSnapshotNoPage(db, nil, nil, nil, snapshotAt)
			dao.Begin(db)
			defer func() {
				if r := recover(); r != nil || err != nil {
					dao.Rollback(db)
					if r != nil {
						panic(r)
					}
				}
			}()
			if len(priceReferSnapshotList) > 0 {
				for _, v := range priceReferSnapshotList {
					result, _ := dao.GetPriceReferPrice(db, v.CityCode, v.SkuID, snapshotAt)
					v.MaxPrice = result.MaxPrice
					v.MinPrice = result.MinPrice
					v.AvgPrice = result.AvgPrice
					v.MidPrice = result.MidPrice
					dao.UpdateEntity(db, v, "MidPrice", "MaxPrice", "MinPrice", "AvgPrice")
				}
			}
			dao.Commit(db)
		}
		return result, err
	}
	taskSeq := tasksch.NewSeqTask2("生成每日价格统计", ctx, isContinueWhenError, taskSeqFunc, 4)
	tasksch.HandleTask(taskSeq, nil, true).Run()
	if !isAsync {
		_, err = taskSeq.GetResult(0)
		hint = "1"
	} else {
		hint = taskSeq.GetID()
	}
	return hint, err
}