package controllers

import (
	"errors"
	"strconv"

	"github.com/astaxie/beego/logs"
	orderCmd "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/order/command"
	orderQuery "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/order/query"
	orderService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/order/service"
	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
)

type OrderController struct {
	BaseController
}

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

type orderDetail struct {
	//买家姓名
	Buyer string `json:"buyer"`
	//买家联系方式
	BuyerPhone string `json:"buyerPhone"`
	//收货地址
	Address string `json:"address"`
	//对应合伙人 id
	Partner int64 `json:"partner"`
	//合伙人抽成比例
	PartnerRatio float64 `json:"partnerRatio"`
	//业务员抽成比例
	SalesmanRatio float64 `json:"salesmanRatio"`
	//订单号
	OrderId string `json:"orderId"`
	//订单名称
	OrderName string `json:"orderName"`
	//订单数量
	OrderNum int `json:"orderNum"`
	//订单金额
	OrderPrice float64 `json:"orderPrice"`
	//订单区域
	OrderDist string `json:"orderDist"`
	//id
	Id int64 `json:"id"`
}

//UpdateOrderPurpose 更新意向订单
func (c *OrderController) UpdateOrderPurpose() {
	//用与适配前端定义的数据结构
	var (
		param orderDetail
		err   error
	)
	if err = c.BindJsonData(&param); err != nil {
		logs.Error(err)
		c.ResponseError(errors.New("json数据解析失败"))
		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 *OrderController) addOrderPurpose(param orderDetail) error {
	orderSrv := orderService.NewOrderService(nil)
	Createcmd := orderCmd.CreateOrderCommand{
		//订单区域
		OrderRegion: param.OrderDist,
		//订单编号
		OrderCode: param.OrderId,
		//订单名称
		OrderName: param.OrderName,
		//数量
		OrderCount: param.OrderNum,
		//订单金额
		OrderAmount: param.OrderPrice,
		//买家
		BuyerName: param.Buyer,
		//买家电话
		BuyerPhone: param.BuyerPhone,
		//地址
		BuyerAddress: param.Address,
		//合伙人数据
		PartnerId: param.Partner,
		//合伙人分红百分比
		PartnerBonusPercent: param.PartnerRatio,
		//业务员分红百分比
		SalesmanBonusPercent: param.SalesmanRatio,
	}
	err := orderSrv.CreateOrderPurpose(Createcmd)
	return err
}

func (c *OrderController) editOrderPurpose(param orderDetail) error {
	updateCmd := orderCmd.UpdateOrderCommand{
		Id: param.Id,
		//订单区域
		OrderRegion: param.OrderDist,
		//订单编号
		OrderCode: param.OrderId,
		//订单名称
		OrderName: param.OrderName,
		//数量
		OrderCount: param.OrderNum,
		//订单金额
		OrderAmount: param.OrderPrice,
		//买家电话
		BuyerPhone: param.BuyerPhone,
		//地址
		BuyerAddress: param.Address,
		//合伙人分红百分比
		PartnerBonusPercent: param.PartnerRatio,
		//业务员分红百分比
		SalesmanBonusPercent: param.SalesmanRatio,
	}
	orderSrv := orderService.NewOrderService(nil)
	err := orderSrv.UpdateOrderPurpose(updateCmd)
	return err
}

//GetOrderPurpose 获取意向订单
func (c *OrderController) 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.NewOrderService(nil)
	orderinfo, err := orderSrv.GetOrder(orderQuery.GetOrderQuery{
		OrderId: orderid,
	})
	if err != nil {
		c.ResponseError(err)
		return
	}
	rsp := map[string]interface{}{
		"createTime":    orderinfo.CreateAt.Local().Format("2006-01-02 15:04:05"),
		"updateTime":    orderinfo.UpdateAt.Local().Format("2006-01-02 15:04:05"),
		"buyer":         orderinfo.Buyer.BuyerName,
		"buyerPhone":    orderinfo.Buyer.ContactInfo,
		"Address":       orderinfo.Buyer.ShippingAddress,
		"id":            orderinfo.Id,
		"partner":       orderinfo.PartnerInfo.Id,
		"partnerRatio":  orderinfo.PartnerBonusPercent,
		"salesmanRatio": orderinfo.SalesmanBonusPercent,
		"orderId":       orderinfo.OrderCode,
		"orderName":     orderinfo.OrderName,
		"OrderNum":      orderinfo.OrderCount,
		"orderPrice":    orderinfo.OrderAmount,
		"orderDist":     orderinfo.OrderRegionInfo.RegionName,
		"orderStatue":   orderinfo.OrderStatus,
	}
	c.ResponseData(rsp)
}

//PageListOrderPurpose 分页获取意向订单列表
func (c *OrderController) PageListOrderPurpose() {
	type Parameter struct {
		SearchText string `json:"searchText"`
		Partner    int64  `json:"parter"`
		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.NewOrderService(nil)
	orderinfos, cnt, err := orderSrv.PageListOrder(orderQuery.ListOrderQuery{
		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.CreateAt.Local().Format("2006-01-02 15:04:05"),
			"updateTime":   orderinfo.UpdateAt.Local().Format("2006-01-02 15:04:05"),
			"buyer":        orderinfo.Buyer.BuyerName,
			"id":           orderinfo.Id,
			"orderId":      orderinfo.OrderCode,
			"partner":      orderinfo.PartnerInfo.PartnerName,
			"partnerRatio": orderinfo.PartnerBonusPercent,
			"orderName":    orderinfo.OrderName,
			"OrderNum":     orderinfo.OrderCount,
			"orderPrice":   orderinfo.OrderAmount,
			"orderDist":    orderinfo.OrderRegionInfo.RegionName,
			"orderStatue":  orderinfo.OrderStatus,
		}
		rsp = append(rsp, m)
	}
	c.ResponsePageList(rsp, cnt, param.PageNumber)
}

//RemoveOrderPurpose 删除意向订单
func (c *OrderController) 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.NewOrderService(nil)
	err = orderSrv.RemoveOrder(param.Id)
	if err != nil {
		c.ResponseError(err)
		return
	}
	c.ResponseData(nil)
}

//PageListOrderReal 分页获取实发订单列表
func (c *OrderController) PageListOrderReal() {
	type Parameter struct {
		SearchText string `json:"searchText"`
		Partner    int64  `json:"parter"`
		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.NewOrderService(nil)
	orderinfos, cnt, err := orderSrv.PageListOrder(orderQuery.ListOrderQuery{
		PartnerId: param.Partner,
		OrderCode: 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.CreateAt.Local().Format("2006-01-02 15:04:05"),
			"updateTime":   orderinfo.UpdateAt.Local().Format("2006-01-02 15:04:05"),
			"buyer":        orderinfo.Buyer.BuyerName,
			"id":           orderinfo.Id,
			"orderId":      orderinfo.OrderCode,
			"partner":      orderinfo.PartnerInfo.PartnerName,
			"partnerRatio": orderinfo.PartnerBonusPercent,
			"orderName":    orderinfo.OrderName,
			"OrderNum":     orderinfo.OrderCount,
			"orderPrice":   orderinfo.OrderAmount,
			"orderDist":    orderinfo.OrderRegionInfo.RegionName,
			"orderStatue":  orderinfo.OrderStatus,
		}
		rsp = append(rsp, m)
	}
	c.ResponsePageList(rsp, cnt, param.PageNumber)
}

//UpdateOrderPurpose 意向订单转实发单
func (c *OrderController) OrderPurposeToReal() {
	//用与适配前端定义的数据结构
	var (
		param orderDetail
		err   error
	)
	if err = c.BindJsonData(&param); err != nil {
		logs.Error(err)
		c.ResponseError(errors.New("json数据解析失败"))
		return
	}

	c.ResponseData(nil)
	return
}