package logic

import (
	"context"
	"errors"
	"lone-services/pkg/log"
	"lone-services/pkg/modelbase"
	"lone-services/pkg/utils"
	"lone-services/pkg/validate"
	product "lone-services/rpc/product/pb"
	"lone-services/services/product/internal/dao"
	"lone-services/services/product/internal/model"
	"lone-services/services/product/internal/svc"
	"lone-services/services/product/validator"
	"strconv"
	"time"

	jsoniter "github.com/json-iterator/go"

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

type CreateLogic struct {
	ctx    context.Context
	svcCtx *svc.ServiceContext
	logx.Logger
}

func NewCreateLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateLogic {
	return &CreateLogic{
		ctx:    ctx,
		svcCtx: svcCtx,
		Logger: logx.WithContext(ctx),
	}
}

func (l *CreateLogic) Create(in *product.CreateReq) (*product.Response, error) {
	var req validator.ProductCreateValidator
	if msg := validate.ValidateFromProto(in, &req); msg != utils.StringEmpty {
		return outResponse(utils.ErrorParams, msg), nil
	}

	if req.Type == dao.ProductTypeNormal {
		if req.AgentPrice == 0 || req.StorePrice == 0 ||
			req.SalePrice == 0 || req.SharePrice == 0 ||
			req.SaleReward == "" {
			return outResponse(utils.ErrorParams, "缺少相关价格"), nil
		}
	}

	publishTime := time.Now()
	if len(req.PublishTime) > 1 {
		t, err := parsePublishTime(req.PublishTime)
		if err != nil {
			return outResponse(utils.ErrorParams, "时间错误"), nil
		}
		publishTime = t
	}

	var check dao.ProductCheckExist
	err := model.ProductModel{}.Init().GetOne(modelbase.Params{
		Eq: map[string]string{"name": req.Name},
	}, &check)
	if err != nil {
		log.Errorf("check product name: %v", err)
		return failResponse(utils.Fail), nil
	}
	if check.Id > 0 {
		return failResponse(utils.ErrorDataIsExist), nil
	}

	adminInfo := utils.GetUserFromCtx(l.ctx)
	if adminInfo.ID < utils.NumberOne {
		return failResponse(utils.ErrorNoLoginInfo), nil
	}
	data := dao.ProductCreate{
		Name:           req.Name,
		Subhead:        req.Subhead,
		Content:        req.Content,
		ModelCode:      req.ModelCode,
		Price:          float32(req.Price),
		StorePrice:     float32(req.StorePrice),
		SalePrice:      float32(req.SalePrice),
		SharePrice:     float32(req.SharePrice),
		AgentPrice:     float32(req.AgentPrice),
		SaleReward:     req.SaleReward,
		Waybill:        req.Waybill,
		SalesModel:     uint8(req.SalesModel),
		Weight:         float32(req.Weight),
		Images:         req.Images,
		PeriodValidity: int16(req.PeriodValidity),
		Type:           uint8(req.Type),
		NormsNumber:    uint8(req.NormsNumber),
		Number:         uint(req.Number),
		Sort:           1,
		Label:          req.Label,
		Cubage:         req.Cubage,
		BoxNumber:      req.BoxNumber,
		IsIndex:        uint8(req.IsIndex),
		IndexImage:     req.IndexImage,
		IsBuy:          uint8(req.IsBuy),
		PublishTime:    publishTime,
		TryNumber:      uint8(req.TryNumber),
		AdminName:      adminInfo.Name,
		AdminId:        int(adminInfo.ID),
	}
	if data.IsIndex == 0 {
		data.IsIndex = 2
	}
	if data.IsBuy == 0 {
		data.IsBuy = 2
	}
	if data.TryNumber == 0 {
		data.TryNumber = 1
	}

	err = l.svcCtx.DB.WithContext(l.ctx).Transaction(func(tx *gorm.DB) error {
		if err := (model.ProductModel{}.Init().WithTX(tx).Create(&data)); err != nil {
			return err
		}

		content := dao.ProductVerify{
			Id:          data.Id,
			ModelCode:   data.ModelCode,
			Price:       data.Price,
			StorePrice:  data.StorePrice,
			SalePrice:   data.SalePrice,
			SharePrice:  data.SharePrice,
			AgentPrice:  data.AgentPrice,
			SaleReward:  data.SaleReward,
			Type:        data.Type,
			BoxNumber:   data.BoxNumber,
			NormsNumber: data.NormsNumber,
			AdminName:   data.AdminName,
			AdminId:     data.AdminId,
		}
		contentBytes, err := jsoniter.Marshal(content)
		if err != nil {
			return err
		}

		verify := dao.VerifyCreate{
			VerifyId: strconv.Itoa(data.Id),
			Content:  string(contentBytes),
			Type:     dao.VerifyTypeProduct,
		}
		return model.VerifyModel{}.Init().WithTX(tx).Create(&verify)
	})
	if err != nil {
		log.Errorf("create product: %v", err)
		return failResponse(utils.Fail), nil
	}

	return okResponse(utils.StringEmpty), nil
}

func parsePublishTime(s string) (time.Time, error) {
	for _, layout := range []string{time.DateTime, time.DateOnly} {
		if t, err := time.ParseInLocation(layout, s, time.Local); err == nil {
			return t, nil
		}
	}
	return time.Time{}, errors.New("invalid time format")
}