package controllers

import (
	"errors"
	"fmt"
	"strconv"
	"time"

	"github.com/astaxie/beego/logs"
	orderCmd "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/orderinfo/command"
	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"
)

type OrderInfoController struct {
	BaseController
}

////Prepare 重写 BaseController 的Prepare方法
func (c *OrderInfoController) Prepare() {
	c.BaseController.Prepare()

	if ok := c.ValidJWTToken(); !ok {
		return
	}
	if ok := c.ValidAdminPermission(domain.PERMISSION_ORDER); !ok {
		return
	}
}

//PageListOrderPurpose 分页获取意向订单列表
func (c *OrderInfoController) PageListOrderPurpose() {
	type Parameter struct {
		SearchText string `json:"searchText"`
		Partner    int64  `json:"partner"`
		PageSize   int    `json:"pageSize"`
		PageNumber int    `json:"pageNumber"`
	}
	var (
		param Parameter
		err   error
	)
	if err = c.BindJsonData(&param); err != nil {
		logs.Error(err)
		c.ResponseError(errors.New("json数据解析失败"))
		return
	}
	if param.PageNumber == 0 {
		param.PageNumber = 1
	}
	if param.PageSize == 0 {
		param.PageSize = 20
	}

	orderSrv := orderService.NewOrderInfoService(nil)
	orderinfos, cnt, err := orderSrv.PageListOrderBase(orderQuery.ListOrderBaseQuery{
		PartnerId: param.Partner,
		OrderCode: param.SearchText,
		OrderType: domain.OrderIntention,
		Limit:     param.PageSize,
		Offset:    (param.PageNumber - 1) * param.PageSize,
	})
	if err != nil {
		c.ResponseError(err)
		return
	}
	rsp := []map[string]interface{}{}
	for i := range orderinfos {
		orderinfo := orderinfos[i]
		m := map[string]interface{}{
			"createTime": orderinfo.CreateTime.Local().Format("2006-01-02 15:04:05"),
			"updateTime": orderinfo.UpdateTime.Local().Format("2006-01-02 15:04:05"),
			"buyer":      orderinfo.Buyer.BuyerName,
			"id":         orderinfo.Id,
			"orderId":    orderinfo.OrderCode,
			"partner":    orderinfo.PartnerInfo.PartnerName,
			"orderNum":   orderinfo.OrderCompute.PlanOrderCount,
			"orderPrice": orderinfo.OrderCompute.PlanOrderAmount,
			"orderDist":  orderinfo.RegionInfo.RegionName,
		}
		rsp = append(rsp, m)
	}
	c.ResponsePageList(rsp, cnt, param.PageNumber)
}

//GetOrderPurpose 获取意向订单详情
func (c *OrderInfoController) GetOrderPurpose() {
	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)
	orderSrv := orderService.NewOrderInfoService(nil)
	orderinfo, err := orderSrv.GetOrderDetail(orderQuery.GetOrderQuery{
		OrderId: orderid,
	})
	if err != nil {
		c.ResponseError(err)
		return
	}
	if orderinfo.OrderType != domain.OrderIntention {
		c.ResponseError(errors.New("参数错误"))
		return
	}
	allGoods := []map[string]interface{}{}
	for _, v := range orderinfo.Goods {
		m := map[string]interface{}{
			"productName":  v.GoodName,
			"orderNum":     v.PlanGoodNumber,
			"univalence":   v.Price,
			"partnerRatio": v.PartnerBonusPercent,
			"orderPrice":   v.GoodCompute.PlanAmount,
		}
		allGoods = append(allGoods, m)
	}
	rsp := map[string]interface{}{
		"buyer":                      orderinfo.Buyer.BuyerName,
		"id":                         orderinfo.Id,
		"partnerID":                  orderinfo.PartnerInfo.Id,
		"partner":                    orderinfo.PartnerInfo.PartnerName,
		"orderDist":                  orderinfo.RegionInfo.RegionName,
		"orderId":                    orderinfo.OrderCode,
		"product":                    allGoods,
		"commissionProportion":       orderinfo.SalesmanBonusPercent,
		"orderNumCount":              orderinfo.OrderCompute.PlanOrderCount,
		"orderAmountAdjustmentCount": orderinfo.OrderCompute.PlanOrderAmount,
	}
	c.ResponseData(rsp)
}

//RemoveOrderPurpose 删除意向订单
func (c *OrderInfoController) RemoveOrderPurpose() {
	type Parameter struct {
		Id int64 `json:"id"`
	}
	var (
		param Parameter
		err   error
	)
	if err = c.BindJsonData(&param); err != nil {
		logs.Error(err)
		c.ResponseError(errors.New("json数据解析失败"))
		return
	}
	orderSrv := orderService.NewOrderInfoService(nil)
	err = orderSrv.DeleteOrder(param.Id)
	if err != nil {
		c.ResponseError(err)
		return
	}
	c.ResponseData(nil)
}

//postPurposeOrderDetail 请求添加/更新的订单数据
type postPurposeOrderDetail struct {
	Id int64 `json:"id"`
	//订单编号
	OrderId string `json:"orderId"`
	//买家姓名
	BuyerName string `json:"buyer"`
	//对应合伙人 id
	PartnerId int64 `json:"partnerID"`
	//业务员抽成比例
	CommissionProportion float64 `json:"commissionProportion"`
	//订单区域
	OrderDist string `json:"orderDist"`
	//商品
	Product []postOrderGood `json:"product"`
}

func (postData postPurposeOrderDetail) Valid() error {
	if len(postData.OrderId) == 0 {
		return lib.ThrowError(lib.ARG_ERROR, "订单编号必填")
	}
	if len(postData.BuyerName) == 0 {
		return lib.ThrowError(lib.ARG_ERROR, "买家信息必填")
	}
	if postData.PartnerId == 0 {
		return lib.ThrowError(lib.ARG_ERROR, "合伙人信息必填")
	}
	if len(postData.OrderDist) == 0 {
		return lib.ThrowError(lib.ARG_ERROR, "订单区域必填")
	}
	for i := range postData.Product {
		if err := postData.Product[i].Valid(); err != nil {
			return err
		}
	}
	return nil
}

//PostPurposeOrderGood 请求添加/更新订单中的货品
type postOrderGood struct {
	Id           int64   `json:"id"`
	ProductName  string  `json:"productName"`
	OrderNum     int     `json:"orderNum"`
	Univalence   float64 `json:"univalence"`
	PartnerRatio float64 `json:"partnerRatio"`
}

func (postData postOrderGood) Valid() error {
	if len(postData.ProductName) == 0 {
		return lib.ThrowError(lib.ARG_ERROR, "商品名称必填")
	}
	return nil
}

//UpdateOrderPurpose 更新意向订单
func (c *OrderInfoController) UpdateOrderPurpose() {
	//用与适配前端定义的数据结构
	var (
		param postPurposeOrderDetail
		err   error
	)
	if err = c.BindJsonData(&param); err != nil {
		logs.Error(err)
		c.ResponseError(errors.New("json数据解析失败"))
		return
	}
	if err := param.Valid(); err != nil {
		c.ResponseError(err)
		return
	}
	if param.Id == 0 {
		err = c.addOrderPurpose(param)
	} else {
		err = c.editOrderPurpose(param)
	}
	if err != nil {
		c.ResponseError(err)
	}
	c.ResponseData(nil)
	return
}

func (c *OrderInfoController) addOrderPurpose(param postPurposeOrderDetail) error {

	newGoods := []orderCmd.OrderGoodData{}
	for _, v := range param.Product {
		g := orderCmd.OrderGoodData{
			GoodName:            v.ProductName,
			PlanGoodNumber:      v.OrderNum,
			Price:               v.Univalence,
			PartnerBonusPercent: v.PartnerRatio,
		}
		newGoods = append(newGoods, g)
	}
	createcmd := orderCmd.CreateOrderCommand{
		OrderType:            domain.OrderIntention,
		OrderCode:            param.OrderId,
		DeliveryCode:         "",
		BuyerName:            param.BuyerName,
		OrderRegion:          param.OrderDist,
		PartnerId:            param.PartnerId,
		SalesmanBonusPercent: param.CommissionProportion,
		Goods:                newGoods,
	}
	orderSrv := orderService.NewOrderInfoService(nil)
	_, err := orderSrv.CreateNewOrder(createcmd)
	return err
}

func (c *OrderInfoController) editOrderPurpose(param postPurposeOrderDetail) error {
	orderSrv := orderService.NewOrderInfoService(nil)
	newGoods := []orderCmd.OrderGoodData{}
	for _, v := range param.Product {
		g := orderCmd.OrderGoodData{
			GoodName:            v.ProductName,
			PlanGoodNumber:      v.OrderNum,
			Price:               v.Univalence,
			PartnerBonusPercent: v.PartnerRatio,
		}
		newGoods = append(newGoods, g)
	}
	updatecmd := orderCmd.UpdateOrderCommand{
		Id:                   param.Id,
		OrderType:            domain.OrderIntention,
		OrderCode:            param.OrderId,
		DeliveryCode:         "",
		BuyerName:            param.BuyerName,
		OrderRegion:          param.OrderDist,
		PartnerId:            param.PartnerId,
		SalesmanBonusPercent: param.CommissionProportion,
		Goods:                newGoods,
	}
	_, err := orderSrv.UpdateOrderData(updatecmd)
	return err
}

type postOrderPurposeDelivery struct {
	ShipmentsId   string          `json:"shipmentsId"` //发货单号
	Id            string          `json:"id"`          //订单id
	ProductDetail []postOrderGood `json:"productDetail"`
}

func (postData postOrderPurposeDelivery) Valid() error {
	if len(postData.ShipmentsId) == 0 {
		return lib.ThrowError(lib.ARG_ERROR, "发货单号必填")
	}
	for i := range postData.ProductDetail {
		if err := postData.ProductDetail[i].Valid(); err != nil {
			return err
		}
	}
	return nil
}

//OrderPurposeDelivery 发货 意向订单转实发单
func (c *OrderInfoController) OrderPurposeDelivery() {
	//用与适配前端定义的数据结构

	var (
		param postOrderPurposeDelivery
		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
	}
	if err = param.Valid(); err != nil {
		c.ResponseError(err)
		return
	}
	goods := []orderCmd.OrderGoodData{}
	for _, v := range param.ProductDetail {
		g := orderCmd.OrderGoodData{
			Id: v.Id, GoodName: v.ProductName, PlanGoodNumber: v.OrderNum,
			Price: v.Univalence, PartnerBonusPercent: v.PartnerRatio,
		}
		goods = append(goods, g)
	}
	deliveryCommand := orderCmd.OrderDeliveryCommand{
		OrderId: orderid, DeliveryCode: param.ShipmentsId,
		DeliveryTime: time.Now(), Goods: goods,
	}
	orderSrv := orderService.NewOrderInfoService(nil)
	err = orderSrv.Delivery(deliveryCommand)
	if err != nil {
		c.ResponseError(err)
	}
	c.ResponseData(nil)
	return
}

//PageListOrderReal 获取实发订单列表
func (c *OrderInfoController) PageListOrderReal() {
	type Parameter struct {
		SearchText string `json:"searchText"`
		Partner    int64  `json:"partner"`
		PageSize   int    `json:"pageSize"`
		PageNumber int    `json:"pageNumber"`
	}
	var (
		param Parameter
		err   error
	)
	if err = c.BindJsonData(&param); err != nil {
		logs.Error(err)
		c.ResponseError(errors.New("json数据解析失败"))
		return
	}
	if param.PageNumber == 0 {
		param.PageNumber = 1
	}
	if param.PageSize == 0 {
		param.PageSize = 20
	}

	orderSrv := orderService.NewOrderInfoService(nil)
	orderinfos, cnt, err := orderSrv.PageListOrderBase(orderQuery.ListOrderBaseQuery{
		PartnerId:    param.Partner,
		DeliveryCode: param.SearchText,
		OrderType:    domain.OrderReal,
		Limit:        param.PageSize,
		Offset:       (param.PageNumber - 1) * param.PageSize,
	})
	if err != nil {
		c.ResponseError(err)
		return
	}
	rsp := []map[string]interface{}{}
	for i := range orderinfos {
		orderinfo := orderinfos[i]
		m := map[string]interface{}{
			"createTime":      orderinfo.CreateTime.Local().Format("2006-01-02 15:04:05"),
			"updateTime":      orderinfo.UpdateTime.Local().Format("2006-01-02 15:04:05"),
			"buyer":           orderinfo.Buyer.BuyerName,
			"id":              orderinfo.Id,
			"orderId":         orderinfo.OrderCode,
			"shipmentsId":     orderinfo.DeliveryCode,
			"partner":         orderinfo.PartnerInfo.PartnerName,
			"orderNum":        orderinfo.OrderCompute.PlanOrderCount,
			"orderPrice":      orderinfo.OrderCompute.PlanOrderAmount,
			"orderDist":       orderinfo.RegionInfo.RegionName,
			"quantityControl": "",
			"priceControl":    "",
			"status":          orderinfo.IsDisable,
		}
		if orderinfo.OrderCompute.UseOrderCount >= 0 {
			m["quantityControl"] = fmt.Sprint(orderinfo.OrderCompute.UseOrderCount)
		}
		if orderinfo.OrderCompute.UseOrderAmount >= 0 {
			m["priceControl"] = fmt.Sprint(orderinfo.OrderCompute.UseOrderAmount)
		}
		rsp = append(rsp, m)
	}
	c.ResponsePageList(rsp, cnt, param.PageNumber)
	return
}

//GetOrderReal 获取实发订单详情
func (c *OrderInfoController) GetOrderReal() {
	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
	}
	orderSrv := orderService.NewOrderInfoService(nil)
	orderinfo, err := orderSrv.GetOrderDetail(orderQuery.GetOrderQuery{
		OrderId: orderid,
	})
	if err != nil {
		c.ResponseError(err)
		return
	}
	if orderinfo.OrderType != domain.OrderReal {
		c.ResponseError(errors.New("参数错误"))
		return
	}
	allGoods := []map[string]interface{}{}
	for _, v := range orderinfo.Goods {
		m := map[string]interface{}{
			"productName":       v.GoodName,
			"orderNum":          v.PlanGoodNumber,
			"univalence":        v.Price,
			"partnerRatio":      v.PartnerBonusPercent,
			"orderPrice":        v.GoodCompute.PlanAmount,
			"quantityControl":   "",
			"orderPriceControl": "",
		}
		if v.GoodCompute.UseAmount >= 0 {
			m["priceControl"] = fmt.Sprint(v.GoodCompute.UseAmount)
		}
		if v.UseGoodNumber >= 0 {
			m["quantityControl"] = fmt.Sprint(v.UseGoodNumber)
		}
		allGoods = append(allGoods, m)
	}
	rsp := map[string]interface{}{
		"buyer":                             orderinfo.Buyer.BuyerName,
		"id":                                orderinfo.Id,
		"partnerID":                         orderinfo.PartnerInfo.Id,
		"partner":                           orderinfo.PartnerInfo.PartnerName,
		"orderDist":                         orderinfo.RegionInfo.RegionName,
		"orderId":                           orderinfo.OrderCode,
		"shipmentsId":                       orderinfo.DeliveryCode,
		"commissionProportion":              orderinfo.SalesmanBonusPercent,
		"orderNumCount":                     orderinfo.OrderCompute.PlanOrderCount,
		"orderAmountAdjustmentCount":        orderinfo.OrderCompute.PlanOrderAmount,
		"orderNumCountControl":              "",
		"orderAmountAdjustmentCountControl": "",
		"product":                           allGoods,
		"create_time":                       orderinfo.CreateTime.Local().Format("2006-01-02 15:04:06"),
		"update_time":                       orderinfo.UpdateTime.Local().Format("2006-01-02 15:04:06"),
	}
	if orderinfo.OrderCompute.UseOrderAmount >= 0 {
		rsp["orderNumCountControl"] = fmt.Sprint(orderinfo.OrderCompute.UseOrderAmount)
	}
	if orderinfo.OrderCompute.UseOrderCount >= 0 {
		rsp["orderAmountAdjustmentCountControl"] = fmt.Sprint(orderinfo.OrderCompute.UseOrderCount)
	}
	c.ResponseData(rsp)
	return
}

//实际订单
type postRealOrderDetail struct {
	postPurposeOrderDetail
	ShipmentsId string `json:"shipmentsId"` //发货单号
}

func (postData postRealOrderDetail) Valid() error {
	if len(postData.ShipmentsId) == 0 {
		return lib.ThrowError(lib.ARG_ERROR, "订单的发货单号必填")
	}
	if err := postData.postPurposeOrderDetail.Valid(); err != nil {
		return err
	}
	return nil
}

//UpdateOrderReal 编辑实际订单
func (c *OrderInfoController) UpdateOrderReal() {
	//用与适配前端定义的数据结构
	var (
		param postRealOrderDetail
		err   error
	)
	if err = c.BindJsonData(&param); err != nil {
		logs.Error(err)
		c.ResponseError(errors.New("json数据解析失败"))
		return
	}
	if err := param.Valid(); err != nil {
		c.ResponseError(err)
		return
	}
	if param.Id == 0 {
		err = c.addOrderReal(param)
	} else {
		err = c.editOrderReal(param)
	}
	if err != nil {
		c.ResponseError(err)
	}
	c.ResponseData(nil)
	return
}

func (c *OrderInfoController) addOrderReal(param postRealOrderDetail) error {
	orderSrv := orderService.NewOrderInfoService(nil)
	newGoods := []orderCmd.OrderGoodData{}
	for _, v := range param.Product {
		g := orderCmd.OrderGoodData{
			GoodName:            v.ProductName,
			PlanGoodNumber:      v.OrderNum,
			Price:               v.Univalence,
			PartnerBonusPercent: v.PartnerRatio,
		}
		newGoods = append(newGoods, g)
	}
	createcmd := orderCmd.CreateOrderCommand{
		OrderType:            domain.OrderReal,
		OrderCode:            param.OrderId,
		DeliveryCode:         param.ShipmentsId,
		BuyerName:            param.BuyerName,
		OrderRegion:          param.OrderDist,
		PartnerId:            param.PartnerId,
		SalesmanBonusPercent: param.CommissionProportion,
		Goods:                newGoods,
	}
	_, err := orderSrv.CreateNewOrder(createcmd)
	return err
}

func (c *OrderInfoController) editOrderReal(param postRealOrderDetail) error {

	newGoods := []orderCmd.OrderGoodData{}
	for _, v := range param.Product {
		g := orderCmd.OrderGoodData{
			GoodName:            v.ProductName,
			PlanGoodNumber:      v.OrderNum,
			Price:               v.Univalence,
			PartnerBonusPercent: v.PartnerRatio,
		}
		newGoods = append(newGoods, g)
	}
	updatecmd := orderCmd.UpdateOrderCommand{
		Id:                   param.Id,
		OrderType:            domain.OrderReal,
		OrderCode:            param.OrderId,
		DeliveryCode:         param.ShipmentsId,
		BuyerName:            param.BuyerName,
		OrderRegion:          param.OrderDist,
		PartnerId:            param.PartnerId,
		SalesmanBonusPercent: param.CommissionProportion,
		Goods:                newGoods,
	}
	orderSrv := orderService.NewOrderInfoService(nil)
	_, err := orderSrv.UpdateOrderData(updatecmd)
	return err
}

//OrderDisable 关闭开启订单，限实发订单可操作
func (c *OrderInfoController) OrderDisable() {
	//用与适配前端定义的数据结构
	type PostParameter struct {
		Id     string `json:"id"`
		Status int    `json:"status"`
	}
	var (
		param PostParameter
		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
	}
	if !(param.Status == domain.OrderDisableNot || param.Status == domain.OrderDisableYes) {
		c.ResponseError(errors.New("参数错误"))
		return
	}
	cmd := orderCmd.DisableOrderCommand{
		OrderId:   orderId,
		IsDisable: param.Status,
		OrderType: domain.OrderReal,
	}
	orderSrv := orderService.NewOrderInfoService(nil)
	err = orderSrv.DisableOrEnable(cmd)
	if err != nil {
		c.ResponseError(err)
	}
	c.ResponseData(nil)
	return
}

//RemoveOrderReal 删除意向订单
func (c *OrderInfoController) RemoveOrderReal() {
	type Parameter struct {
		Id int64 `json:"id"`
	}
	var (
		param Parameter
		err   error
	)
	if err = c.BindJsonData(&param); err != nil {
		logs.Error(err)
		c.ResponseError(errors.New("json数据解析失败"))
		return
	}
	orderSrv := orderService.NewOrderInfoService(nil)
	err = orderSrv.DeleteOrder(param.Id)
	if err != nil {
		c.ResponseError(err)
		return
	}
	c.ResponseData(nil)
}