package service

import (
	"context"
	"errors"
	"fmt"
	"github.com/fonchain_enterprise/fonchain-main/pkg/model/login"
	"github.com/fonchain_enterprise/fonchain-main/pkg/model/vo"

	"dubbo.apache.org/dubbo-go/v3/common/logger"
	"github.com/fonchain_enterprise/fonchain-main/api/express"
	"github.com/fonchain_enterprise/fonchain-main/api/order"
	"github.com/fonchain_enterprise/fonchain-main/pkg/e"

	"github.com/gin-gonic/gin"
)

//修改开发板信息 单个
func EditSinglechip(c *gin.Context) {
	//声明一个变量
	var req express.SinglechipRequest

	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("Update ShouldBind err", err)
		Error(c, e.Error, err)
		return
	}
	resp, err := GrpcExpressImpl.Update(context.Background(), &req)
	if err != nil {
		Error(c, e.Error, err)
		return
	}
	Success(c, resp)
	return
}

//BatchEditSinglechip 修改开发板信息 单个
func BatchEditSinglechip(c *gin.Context) {
	//声明一个变量
	var req vo.BatchSingle

	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("Update ShouldBind err", err)
		Error(c, e.Error, err)
		return
	}

	var resp *express.SinglechipResponse
	for i, _ := range req.Data {
		var err error
		resp, err = GrpcExpressImpl.Update(context.Background(), req.Data[i])
		if err != nil {
			Error(c, e.Error, err)
			return
		}
	}

	Success(c, resp)
	return
}

//更新快递柜
func EditCircuit(c *gin.Context) {
	var req express.CircuitRequest
	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("Updatecircuit ShouldBind err", err)
		Error(c, e.Error, err)
		return
	}

	resp, err := GrpcExpressImpl.UpdateCircuit(context.Background(), &req)
	if err != nil {
		Error(c, e.Error, err)
		return
	}
	Success(c, resp)
	return
}

//柜门修改开闭状态
func SetCircuitStatus(c *gin.Context) {
	Success(c, nil)
	return
}

//快递柜列表
func ListCircuit(c *gin.Context) {
	var req express.CircuitList
	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("CircuitList ShouldBind err", err)
		Error(c, e.Error, err)
		return
	}

	resp, err := GrpcExpressImpl.ListCircuit(context.Background(), &req)
	if err != nil {
		Error(c, e.Error, err)
		return
	}
	Success(c, resp)
	return
}

//寄件历史明细
func HistoryList(c *gin.Context) {

	var req express.CircuitHistoryList
	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("HistoryList ShouldBind err", err)
		Error(c, e.Error, err)
		return
	}

	resp, err := GrpcExpressImpl.ListCircuitHistory(context.Background(), &req)
	if err != nil {
		Error(c, e.Error, err)
		return
	}
	Success(c, resp)
	return
}

//开发板开启关闭状态
func Open(c *gin.Context) {

	var req express.CircuitOpen
	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("Open ShouldBind err", err)
		ResponseQuickMsg(c, e.Failed, err.Error(), nil)
		return
	}

	resp, err := GrpcExpressImpl.OpenCircuit(context.Background(), &req)
	if err != nil {
		Error(c, e.Error, err)
		return
	}
	Success(c, resp)
	return
}

//创建生成开发板
func Create(c *gin.Context) {
	var req express.SinglechipRequest
	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("Create ShouldBind err", err)
		ResponseQuickMsg(c, e.Failed, err.Error(), nil)
		return
	}

	resp, err := GrpcExpressImpl.Create(context.Background(), &req)
	if err != nil {
		Error(c, e.Error, err)
		return
	}
	Success(c, resp)
	return
}

//开发板一键删除
func Remove(c *gin.Context) {

	var req express.SinglechipDetail
	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("Remove ShouldBind err", err)
		Error(c, e.Error, err)
		return
	}

	resp, err := GrpcExpressImpl.Remove(context.Background(), &req)
	if err != nil {
		Error(c, e.Error, err)
		return
	}
	Success(c, resp)
	return
}

//列表
func ExpressList(c *gin.Context) {

	var req express.SinglechipList

	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("Remove ShouldBind err", err)
		Error(c, e.Error, err)
		return
	}

	resp, err := GrpcExpressImpl.List(context.Background(), &req)
	if err != nil {
		Error(c, e.Error, err)
		return

	}
	Success(c, resp)
	return
}

//寄件
func Send(c *gin.Context) {
	var req express.BatchCircuitHistoryRequest
	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("Send ShouldBind err", err)
		Error(c, e.Error, err)
		return
	}

	userInfo := login.GetUserInfoFromC(c)

	//获取所有的ArtworkNum
	var artworkNum []string
	for _, temp := range req.List {
		artworkNum = append(artworkNum, temp.ArtworkNum)
	}

	baseReq := order.OrdersByArtworkNumRequest{ArtworkNums: artworkNum}
	baseRes, baseErr := OrderProvider.OrdersByArtworkNum(c, &baseReq)
	if baseErr != nil {
		Error(c, e.Error, baseErr)
		return
	}

	if len(baseRes.Bases) <= 0 {
		Error(c, e.Error, errors.New("当前选中作品并没有销售记录"))
		return
	}

	baseInfoMap := make(map[string]*order.OrderBaseInfo)
	for _, temp := range baseRes.Bases {
		baseInfoMap[temp.ArtworkNum] = temp
	}

	fmt.Println("map:", baseInfoMap)

	for index, temp := range req.List {

		req.List[index].Operation = "寄件"
		req.List[index].OperatorID = userInfo.ID
		req.List[index].OperatorName = userInfo.NickName
		if _, ok := baseInfoMap[temp.ArtworkNum]; ok != true {
			continue
		}
		req.List[index].SellerID = baseInfoMap[temp.ArtworkNum].SellerID
		req.List[index].SellerName = baseInfoMap[temp.ArtworkNum].SellerName
		req.List[index].BuyerName = baseInfoMap[temp.ArtworkNum].BuyerName
	}

	fmt.Println("插入数据", req.List)

	resp, err := GrpcExpressImpl.BatchCreateCircuitHistory(context.Background(), &req)
	if err != nil {
		Error(c, e.Error, baseErr)
		return
	}
	Success(c, resp)
	return
}