package svc

import (
	"context"
	"lone-services/pkg/modelbase"
	"lone-services/pkg/utils"
	order "lone-services/rpc/order/pb"
	"lone-services/services/express/internal/dao"
	"lone-services/services/express/internal/model"
	"lone-services/services/express/internal/transit"
	"strconv"

	"github.com/zeromicro/go-zero/core/logx"
)

func Cancel(client transit.Transit, w modelbase.Params, info dao.DeliveryOrderPrintEdit, status uint8, name string) utils.Status {
	sn := info.OrderSn
	if info.TransitType == dao.ExpressCompanyJd {
		sn = info.TransitSn
	}

	ret, canErr := client.Cancel(sn)
	if canErr != nil || ret.ErrorCode != utils.StringStatusOk {
		logx.Error("cancel order err ", sn, canErr, ret)
		return utils.ErrorInternalServer
	}
	var history dao.DeliveryHistoryCreate
	history.DeliverId = info.Id
	history.TransitName = dao.DeliverySendType[info.TransitType]
	history.TransitInfo = ret.PostInfo
	history.TransitContent = ret.RequestInfo
	history.TransitType = info.TransitType
	history.OrderSn = info.OrderSn

	info.OrderSn = utils.StringEmpty
	info.Status = status
	info.Express = utils.StringEmpty
	modelObj := model.DeliveryOrderModel{}.Init()

	modelObj.Begin()
	_, err := modelObj.Edit(w, &info)
	if err != nil {
		logx.Error("cancel up order err ", info.Id, err)
		modelObj.Rollback()
		return utils.Fail
	}
	err = model.DeliveryHistoryModel{}.Init().Create(&history)
	if err != nil {
		logx.Error("cancel up order err ", info.Id, err)
		modelObj.Rollback()
		return utils.Fail
	}
	ww := modelbase.Params{Eq: map[string]string{"delivery_order_id": strconv.Itoa(info.Id)}}
	editExp := dao.DeliveryExpStatus{
		Status: utils.StatusFail,
	}
	_, err = model.DeliveryOrderExpModel{}.Init().Edit(ww, &editExp)
	if err != nil {
		logx.Error("cancel up order err ", info.Id, err)
		modelObj.Rollback()
		return utils.Fail
	}

	s := UpOrderDeliverStatus(name, info.ObjId, int(info.Type), int32(status))
	if s != utils.Ok {
		modelObj.Rollback()
		return s
	}
	modelObj.Commit()

	return utils.Ok
}

func UpOrderDeliverStatus(name string, id string, Type int, status int32) utils.Status {
	if Type == dao.DeliveryTypeOrder {
		cli, err := GetRpcClient(name)
		if err != nil {
			logx.Errorf("get order err: %v", err)
			return utils.ErrorInternalServer
		}

		client := order.NewOrderClient(cli.Conn())
		update := order.UpdateOrderDeliverStatusRequest{Id: id, DeliverStatus: status}
		if status == dao.SendStatusOver {
			update.SignTime = utils.Now().GoString()
		}
		_, err = client.UpdateOrderDeliverStatus(context.Background(), &update)
		if err != nil {
			logx.Errorf("get order err: %v", err)
			return utils.ErrorInternalServer
		}
	}

	return utils.Ok
}

func GetTransitInfo(transitInfo dao.ExpressSend) (transit.Transit, utils.Status) {
	var client transit.Transit
	switch transitInfo.TransitId {
	case dao.ExpressCompanySf:
		client = transit.NewSfClient(transitInfo)
	case dao.ExpressCompanyJd:
		client = transit.NewJdClient(transitInfo)
	default:
		return client, utils.SetError(utils.ErrorNotFund, "没有找到快递公司")
	}

	return client, utils.Ok
}

func GetOrderInfo(sn string, Type int32, name string) *order.OrderInfoResponse {
	cli, err := GetRpcClient(name)
	var info *order.OrderInfoResponse
	if err != nil {
		logx.Errorf("get order err: %v", err)
		return info
	}

	client := order.NewOrderClient(cli.Conn())
	info, err = client.GetOrderInfo(context.Background(), &order.GetOrderInfoRequest{OrderSn: sn, Type: Type})
	if err != nil {
		logx.Errorf("get order err: %v", err)
		return info
	}
	return info
}

func QueryEdit(data map[string]interface{}, goods *dao.DeliveryOrderUpTransit, name string) ([]dao.ExpressQueryItems, utils.Status) {
	routeResps, ok := data["routeResps"].([]interface{})
	if !ok || len(routeResps) == 0 {
		logx.Error("routeResps 为空")
		return nil, utils.SetError(utils.ErrorNotFund, "获取快递错误")
	}

	firstResp, ok := routeResps[0].(map[string]interface{})
	if !ok {
		logx.Error("routeResps 为空")
		return nil, utils.SetError(utils.ErrorNotFund, "获取快递错误")

	}
	routes, ok := firstResp["routes"].([]interface{})
	if !ok {
		logx.Error("routes 为空")
		return nil, utils.SetError(utils.ErrorNotFund, "获取快递错误")

	}

	status := false
	var items []dao.ExpressQueryItems
	for _, item := range routes {
		route, ok := item.(map[string]interface{})
		if !ok {
			continue
		}
		tmp := dao.ExpressQueryItems{
			AcceptAddress:       route["acceptAddress"].(string),
			AcceptTime:          route["acceptTime"].(string),
			FirstStatusCode:     route["firstStatusCode"].(string),
			FirstStatusName:     route["firstStatusName"].(string),
			OpCode:              route["opCode"].(string),
			Remark:              route["remark"].(string),
			SecondaryStatusCode: route["secondaryStatusCode"].(string),
			SecondaryStatusName: route["secondaryStatusName"].(string),
		}
		items = append(items, tmp)
		if ok := transit.SfSingedCodeMap[tmp.OpCode]; ok {
			status = true
		}
	}

	modelObj := model.DeliveryOrderModel{}.Init()
	modelObj.Begin()
	if status {
		goods.Status = dao.SendStatusOver
		goods.SignTime = utils.Now()
		ww := modelbase.Params{Eq: map[string]string{"delivery_order_id": strconv.Itoa(goods.Id)}}
		editExp := dao.DeliveryExpStatus{
			Status: utils.StatusFail,
		}
		_, err := model.DeliveryOrderExpModel{}.Init().Edit(ww, &editExp)
		if err != nil {
			modelObj.Rollback()
			logx.Error("update deleverGoodsExp err", err)
			return nil, utils.SetError(utils.ErrorNotFund, "更新数据出错")
		}
	}

	goods.TransitQuery = utils.StructToJson(items)
	w := modelbase.Params{Eq: map[string]string{"id": strconv.Itoa(goods.Id)}}
	_, err := modelObj.Edit(w, goods)
	if err != nil {
		modelObj.Rollback()
		logx.Error("update deleverGoods err", err)
		return nil, utils.SetError(utils.ErrorNotFund, "更新数据出错")
	}

	s := UpOrderDeliverStatus(name, goods.ObjId, int(goods.Type), dao.SendStatusOver)
	if s != utils.Ok {
		modelObj.Rollback()
		return nil, s
	}
	modelObj.Commit()
	return items, utils.Ok
}
func QueryJdEdit(data map[string]interface{}, goods *dao.DeliveryOrderUpTransit, name string) ([]dao.ExpressQueryItems, utils.Status) {
	routeResps, ok := data["traceDetails"].([]interface{})
	if !ok || len(routeResps) == 0 {
		logx.Error("routeResps 为空")
		return nil, utils.SetError(utils.ErrorNotFund, "获取快递错误")
	}

	status := false
	var items []dao.ExpressQueryItems
	for _, item := range routeResps {
		route, ok := item.(map[string]interface{})
		if !ok {
			continue
		}
		categoryStr := utils.StringEmpty
		if category, ok := route["category"]; ok {
			categoryStr = strconv.Itoa(int(category.(float64)))
		}
		tmp := dao.ExpressQueryItems{
			OpCode:     route["state"].(string),
			Remark:     route["operationRemark"].(string),
			AcceptTime: route["operationTime"].(string),

			FirstStatusCode: categoryStr,
			FirstStatusName: route["categoryName"].(string),
			OperatorName:    route["operatorName"].(string),
			OperationTitle:  route["operationTitle"].(string),
		}
		tmp.LastMd5 = utils.MD5Encrypt(tmp.Remark + tmp.AcceptTime +
			tmp.OperatorName)
		items = append(items, tmp)
		if ok := transit.JdSingedCodeMap[tmp.OpCode]; ok {
			status = true
		}
	}

	modelObj := model.DeliveryOrderModel{}.Init()
	modelObj.Begin()
	if status {
		goods.Status = dao.SendStatusOver
		goods.SignTime = utils.Now()
		ww := modelbase.Params{Eq: map[string]string{"delivery_order_id": strconv.Itoa(goods.Id)}}
		editExp := dao.DeliveryExpStatus{
			Status: utils.StatusOk,
		}
		_, err := model.DeliveryOrderExpModel{}.Init().Edit(ww, &editExp)
		if err != nil {
			modelObj.Rollback()
			logx.Error("update deleverGoodsExp err", err)
			return nil, utils.SetError(utils.ErrorNotFund, "更新数据出错")
		}

		s := UpOrderDeliverStatus(name, goods.ObjId, int(goods.Type), dao.SendStatusOver)
		if s != utils.Ok {
			modelObj.Rollback()
			return nil, s
		}
	}

	goods.TransitQuery = utils.StructToJson(items)
	w := modelbase.Params{Eq: map[string]string{"id": strconv.Itoa(goods.Id)}}
	_, err := modelObj.Edit(w, goods)
	if err != nil {
		modelObj.Rollback()
		logx.Error("update deleverGoods err", err)
		return nil, utils.SetError(utils.ErrorNotFund, "更新数据出错")
	}

	modelObj.Commit()
	return items, utils.Ok
}