package controllers

import (
	"errors"
	"strconv"
	"time"

	"github.com/astaxie/beego/logs"
	orderQuery "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/orderinfo/query"
	orderService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/orderinfo/service"
	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/lib/exceltool"
)

//OrderDividendController 订单分红管理
type OrderDividendController struct {
	BaseController
}

//Prepare 重写 BaseController 的Prepare方法
func (c *OrderDividendController) Prepare() {
	c.BaseController.Prepare()
	if ok := c.ValidJWTToken(); !ok {
		return
	}
	if ok := c.ValidAdminPermission(domain.PERMISSION_DIVIDEND); !ok {
		return
	}
}

//PageListOrderDividend 获取实发订单分红列表
func (c *OrderDividendController) PageListOrderDividend() {
	type Parameter struct {
		SearchWord        string   `json:"searchWord"`
		OrderType         int      `json:"orderType"`
		PageSize          int      `json:"pageSize"`
		PageNumber        int      `json:"pageNumber"`
		PartnerCategoryId int      `json:"partnerCategoryId"`
		CreateTime        []string `json:"createTime"`
	}
	var (
		param Parameter
		err   error
	)
	if err = c.BindJsonData(&param); err != nil {
		logs.Error(err)
		c.ResponseError(errors.New("json数据解析失败"))
		return
	}
	if !(param.OrderType == 0 ||
		param.OrderType == domain.OrderReal ||
		param.OrderType == domain.OrderTypeBestShop) {
		c.ResponseError(errors.New("参数异常"))
		return
	}
	if param.PageNumber == 0 {
		param.PageNumber = 1
	}
	if param.PageSize == 0 {
		param.PageSize = 20
	}

	var (
		createTimeBegin string
		createTimeEnd   string
	)
	if len(param.CreateTime) > 0 {
		if len(param.CreateTime[0]) > 0 {
			t, err := time.ParseInLocation("2006-01-02", param.CreateTime[0], time.Local)
			if err != nil {
				c.ResponseError(errors.New("UpdateTimeBegin 时间格式错误"))
				return
			}
			createTimeBegin = t.Format("2006-01-02 15:04:05-07")
		}
	}
	if len(param.CreateTime) > 1 {
		if len(param.CreateTime[1]) > 0 {
			t, err := time.ParseInLocation("2006-01-02", param.CreateTime[1], time.Local)
			if err != nil {
				c.ResponseError(errors.New("UpdateTimeEnd 时间格式错误"))
				return
			}
			//设定时间边界
			t = t.Add(86399 * time.Second)
			createTimeEnd = t.Format("2006-01-02 15:04:05-07")
		}
	}
	companyId := c.GetUserCompany()
	orderSrv := orderService.NewOrderInfoService(nil)
	resp, cnt, err := orderSrv.PageListOrderBonus(orderQuery.ListOrderBonusQuery{
		OrderType:       param.OrderType,
		PartnerOrCode:   param.SearchWord,
		Limit:           param.PageSize,
		Offset:          (param.PageNumber - 1) * param.PageSize,
		CompanyId:       companyId,
		PartnerCategory: param.PartnerCategoryId,
		CreateTimeBegin: createTimeBegin,
		CreateTimeEnd:   createTimeEnd,
	})
	if err != nil {
		c.ResponseError(err)
		return
	}
	c.ResponsePageList(resp, cnt, param.PageNumber)
	return
}

func (c *OrderDividendController) OrderDividendDetail() {
	type Parameter struct {
		Id string `json:"id"`
	}
	var (
		param Parameter
		err   error
	)
	if err = c.BindJsonData(&param); err != nil {
		logs.Error(err)
		c.ResponseError(errors.New("json数据解析失败"))
		return
	}
	orderid, _ := strconv.ParseInt(param.Id, 10, 64)
	if orderid == 0 {
		c.ResponseError(errors.New("参数错误"))
		return
	}
	companyId := c.GetUserCompany()
	orderSrv := orderService.NewOrderInfoService(nil)
	orderinfo, err := orderSrv.GetOrderInfoWithBonus(orderid, companyId)
	if err != nil {
		c.ResponseError(err)
		return
	}
	c.ResponseData(orderinfo)
	return
}

// type postOrderDividend struct {
// 	Id               int64                 `json:"id"`
// 	DividendPayments []postDividendPayment `json:"dividendPayment"`
// }

// type postDividendPayment struct {
// 	QuantityControl string `json:"quantityControl"`
// 	StateOfPayment  int    `json:"stateOfPayment"`
// 	ProductId       int64  `json:"productId"`
// 	Remark          string `json:"remark"`
// }

//OrderDividendDetailForBestshop 海鲜干货的订单分红详情
func (c *OrderDividendController) OrderDividendDetailForBestshop() {
	type Parameter struct {
		Id string `json:"id"`
	}
	var (
		param Parameter
		err   error
	)
	if err = c.BindJsonData(&param); err != nil {
		logs.Error(err)
		c.ResponseError(errors.New("json数据解析失败"))
		return
	}
	orderid, _ := strconv.ParseInt(param.Id, 10, 64)
	if orderid == 0 {
		c.ResponseError(errors.New("参数错误"))
		return
	}
	companyId := c.GetUserCompany()
	orderSrv := orderService.NewOrderInfoService(nil)
	respData, err := orderSrv.GetOrderBestshopInfoWithBonus(orderid, companyId)
	if err != nil {
		c.ResponseError(err)
		return
	}
	c.ResponseData(respData)
	return
}

//EditOrderForBestshop 编辑订单分红详情中的 货品数量和分红比例
func (c *OrderDividendController) EditOrderDividend() {
	type Parameter struct {
		State               int     `json:"state"`
		OrderId             string  `json:"orderId"`
		ProductId           string  `json:"productId"`
		Reason              string  `json:"reason"`
		GoodNumber          int     `json:"goodNumber"`
		PartnerBonusPercent float64 `json:"partnerBonusPercent"`
	}
	var (
		param Parameter
		err   error
	)
	if err = c.BindJsonData(&param); err != nil {
		logs.Error(err)
		c.ResponseError(errors.New("json数据解析失败"))
		return
	}
	orderid, _ := strconv.ParseInt(param.OrderId, 10, 64)
	if orderid == 0 {
		c.ResponseError(errors.New("参数错误"))
		return
	}
	productId, _ := strconv.ParseInt(param.ProductId, 10, 64)
	if productId == 0 {
		c.ResponseError(errors.New("参数错误"))
		return
	}
	adminId := c.GetUserId()
	orderSrv := orderService.NewOrderInfoService(nil)

	switch param.State {
	case 1:
		err = orderSrv.UpdateBonusByGoodNumber(orderid, productId, adminId, param.GoodNumber, param.Reason)
	case 2:
		err = orderSrv.UpdateBonusByPartnerBonusPercent(orderid, productId, adminId, param.PartnerBonusPercent, param.Reason)
	}
	if err != nil {
		c.ResponseError(err)
		return
	}
	c.ResponseData(nil)
	return
}

//PayOrderGoodBonus 支付订单中的分红
func (c *OrderDividendController) PayOrderGoodBonus() {
	type Parameter struct {
		OrderId   string `json:"orderId"`
		ProductId string `json:"productId"`
	}
	var (
		param Parameter
		err   error
	)
	if err = c.BindJsonData(&param); err != nil {
		logs.Error(err)
		c.ResponseError(errors.New("json数据解析失败"))
		return
	}
	orderid, _ := strconv.ParseInt(param.OrderId, 10, 64)
	if orderid == 0 {
		c.ResponseError(errors.New("参数错误"))
		return
	}
	productId, _ := strconv.ParseInt(param.ProductId, 10, 64)
	if productId == 0 {
		c.ResponseError(errors.New("参数错误"))
		return
	}
	adminId := c.GetUserId()
	orderSrv := orderService.NewOrderInfoService(nil)
	err = orderSrv.PayPartnerBonus(orderid, productId, adminId)
	if err != nil {
		c.ResponseError(err)
		return
	}
	c.ResponseData(nil)
	return
}

//EditOrderRemarkBonus 编辑订单分红详情中的备注
func (c *OrderDividendController) EditOrderRemarkBonus() {
	type Parameter struct {
		OrderId string `json:"orderId"`
		Remark  string `json:"remark"`
	}
	var (
		param Parameter
		err   error
	)
	if err = c.BindJsonData(&param); err != nil {
		logs.Error(err)
		c.ResponseError(errors.New("json数据解析失败"))
		return
	}
	orderid, _ := strconv.ParseInt(param.OrderId, 10, 64)
	if orderid == 0 {
		c.ResponseError(errors.New("参数错误"))
		return
	}

	adminId := c.GetUserId()
	orderSrv := orderService.NewOrderInfoService(nil)
	err = orderSrv.UpdateOrderRemarkBonus(orderid, adminId, param.Remark)
	if err != nil {
		c.ResponseError(err)
		return
	}
	c.ResponseData(nil)
	return
}

func (c *OrderDividendController) ListOrderBonusForExcel() {
	type Parameter struct {
		SearchWord        string `json:"searchWord"`
		OrderType         int    `json:"orderType"`
		PageSize          int    `json:"pageSize"`
		PageNumber        int    `json:"pageNumber"`
		PartnerCategoryId int    `json:"partnerCategoryId"`
	}
	var (
		param Parameter
		err   error
	)
	if err = c.BindJsonData(&param); err != nil {
		logs.Error(err)
		c.ResponseError(errors.New("json数据解析失败"))
		return
	}
	if !(param.OrderType == 0 ||
		param.OrderType == domain.OrderReal ||
		param.OrderType == domain.OrderTypeBestShop) {
		c.ResponseError(errors.New("参数异常"))
		return
	}

	companyId := c.GetUserCompany()
	orderSrv := orderService.NewOrderInfoService(nil)
	dataResult, column, err := orderSrv.ListOrderBonusForExcel(
		orderQuery.ListOrderBonusQuery{
			OrderType:       param.OrderType,
			PartnerOrCode:   param.SearchWord,
			CompanyId:       companyId,
			PartnerCategory: param.PartnerCategoryId,
		})
	if err != nil {
		c.ResponseError(err)
		return
	}
	var excelHeaders []exceltool.ExcelHead
	for i := range column {
		h := exceltool.ExcelHead{
			Key:  column[i][0],
			Name: column[i][1],
		}
		excelHeaders = append(excelHeaders, h)
	}
	excelMaker := exceltool.NewExcelMaker()
	excelMaker.SetListHead(excelHeaders)
	excelMaker.MakeListExcel(dataResult)
	c.ResponseExcelByFile(c.Ctx, excelMaker)
	return
}

//BatchPayOrderGoodBonus 批量支付订单中的分红
func (c *OrderDividendController) BatchPayOrderGoodBonus() {
	type Parameter struct {
		OrderIds []string `json:"orderIds"`
	}
	var (
		param Parameter
		err   error
	)
	if err = c.BindJsonData(&param); err != nil {
		logs.Error(err)
		c.ResponseError(errors.New("json数据解析失败"))
		return
	}
	orderIds := []int64{}
	for _, v := range param.OrderIds {
		id, _ := strconv.ParseInt(v, 10, 64)
		orderIds = append(orderIds, id)
	}
	adminId := c.GetUserId()
	orderSrv := orderService.NewOrderInfoService(nil)

	err = orderSrv.BatchPayPartnerBonus(orderIds, adminId)
	if err != nil {
		c.ResponseError(err)
		return
	}
	c.ResponseData(nil)
	return
}