package repository

import (
	"fmt"

	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/pg/models"
	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/pg/transaction"
)

type OrderBaseRepository struct {
	transactionContext *transaction.TransactionContext
}

var (
	_ domain.OrderBaseRepository = (*OrderBaseRepository)(nil)
)

func NewOrderBaseRepository(transactionContext *transaction.TransactionContext) (*OrderBaseRepository, error) {
	if transactionContext == nil {
		return nil, fmt.Errorf("transactionContext参数不能为nil")
	}
	return &OrderBaseRepository{transactionContext: transactionContext}, nil
}

func (reponsitory OrderBaseRepository) transformPgModelToDomainModel(orderModel *models.OrderBase) (order domain.OrderBase, err error) {
	order = domain.OrderBase{
		Id: orderModel.Id, OrderType: orderModel.OrderType, OrderCode: orderModel.OrderCode,
		DeliveryCode: orderModel.DeliveryCode, Buyer: orderModel.Buyer, RegionInfo: orderModel.RegionInfo,
		PartnerId: orderModel.PartnerId, SalesmanBonusPercent: orderModel.SalesmanBonusPercent,
		CreateTime: orderModel.CreateTime, DeliveryTime: orderModel.DeliveryTime, UpdateTime: orderModel.UpdateTime,
		IsDisable: orderModel.IsDisable,
		OrderCompute: domain.OrderCompute{
			PlanPartnerBonus: orderModel.PlanPartnerBonus, UsePartnerBonus: orderModel.UsePartnerBonus,
			PartnerBonusHas: orderModel.PartnerBonusHas, PartnerBonusNot: orderModel.PartnerBonusNot,
			PartnerBonusExpense: orderModel.PartnerBonusExpense, SalesmanBonus: orderModel.SalesmanBonus,
			PlanOrderCount: orderModel.PlanOrderCount, PlanOrderAmount: orderModel.PlanOrderAmount,
			UseOrderCount: orderModel.UseOrderCount, UseOrderAmount: orderModel.UseOrderAmount,
		},
		PartnerInfo: domain.Partner{
			Id: orderModel.PartnerId,
		},
		BonusStatus: orderModel.BonusStatus,
		CompanyId:   orderModel.CompanyId,
	}
	return order, nil
}

func (repository OrderBaseRepository) Save(orderInfo *domain.OrderBase) error {
	var (
		err error
		tx  = repository.transactionContext.PgTx
	)
	m := &models.OrderBase{
		Id: orderInfo.Id, OrderType: orderInfo.OrderType, OrderCode: orderInfo.OrderCode,
		DeliveryCode: orderInfo.DeliveryCode, Buyer: orderInfo.Buyer, RegionInfo: orderInfo.RegionInfo,
		PartnerId: orderInfo.PartnerId, SalesmanBonusPercent: orderInfo.SalesmanBonusPercent,
		SalesmanBonus: orderInfo.OrderCompute.SalesmanBonus, PlanOrderCount: orderInfo.OrderCompute.PlanOrderCount,
		PlanOrderAmount: orderInfo.OrderCompute.PlanOrderAmount, UseOrderCount: orderInfo.OrderCompute.UseOrderCount,
		UseOrderAmount: orderInfo.OrderCompute.UseOrderAmount, DeliveryTime: orderInfo.DeliveryTime,
		PlanPartnerBonus: orderInfo.OrderCompute.PlanPartnerBonus, UsePartnerBonus: orderInfo.OrderCompute.UsePartnerBonus,
		PartnerBonusHas: orderInfo.OrderCompute.PartnerBonusHas, PartnerBonusNot: orderInfo.OrderCompute.PartnerBonusNot,
		PartnerBonusExpense: orderInfo.OrderCompute.PartnerBonusExpense, IsDisable: orderInfo.IsDisable,
		CreateTime: orderInfo.CreateTime, BonusStatus: orderInfo.BonusStatus,
		CompanyId: orderInfo.CompanyId,
	}
	if m.Id == 0 {
		_, err = tx.Model(m).
			Returning("*").
			Insert()
		orderInfo.Id = m.Id
		orderInfo.CreateTime = m.CreateTime
		orderInfo.UpdateTime = m.UpdateTime
	} else {
		_, err = tx.Model(m).
			WherePK().
			Returning("*").
			Update()
		orderInfo.UpdateTime = m.UpdateTime
	}
	return err
}

func (repository OrderBaseRepository) Find(queryOption domain.OrderBaseFindQuery) ([]domain.OrderBase, int, error) {
	db := repository.transactionContext.PgDd
	orderModels := []models.OrderBase{}
	query := db.Model(&orderModels)
	if queryOption.PartnerId > 0 {
		query = query.Where("partner_id=?", queryOption.PartnerId)
	}
	if len(queryOption.OrderCode) > 0 {
		query = query.Where("order_code like ?", "%"+queryOption.OrderCode+"%")
	}
	if len(queryOption.DeliveryCode) > 0 {
		query = query.Where("delivery_code like ?", "%"+queryOption.DeliveryCode+"%")
	}
	if queryOption.OrderType > 0 {
		query = query.Where("order_type=?", queryOption.OrderType)
	}
	if queryOption.CompanyId > 0 {
		query = query.Where("company_id=?", queryOption.CompanyId)
	}
	if queryOption.Offset > -1 {
		query = query.Offset(queryOption.Offset)
	}
	if queryOption.Limit > 0 {
		query = query.Limit(queryOption.Limit)
	} else {
		query = query.Limit(20)
	}
	var (
		err          error
		ordersReturn = make([]domain.OrderBase, 0)
	)
	query = query.Order("order_base.id DESC")
	count, err := query.SelectAndCount()
	if err != nil {
		return ordersReturn, 0, err
	}
	for i := range orderModels {
		domainOrder, err := repository.transformPgModelToDomainModel(&orderModels[i])
		if err != nil {
			return ordersReturn, 0, err
		}
		ordersReturn = append(ordersReturn, domainOrder)
	}
	return ordersReturn, count, nil
}

func (repository OrderBaseRepository) FindOne(qureyOptions domain.OrderBaseFindOneQuery) (*domain.OrderBase, error) {
	var (
		err error
		tx  = repository.transactionContext.PgDd
	)
	m := new(models.OrderBase)
	query := tx.Model(m).
		Where("id=?", qureyOptions.OrderId)
	if qureyOptions.CompanyId > 0 {
		query = query.Where("company_id=?", qureyOptions.CompanyId)
	}
	err = query.First()
	if err != nil {
		return nil, err
	}
	result, err := repository.transformPgModelToDomainModel(m)
	return &result, err
}

func (repository OrderBaseRepository) Remove(id int64, companyId int64) error {
	var (
		err error
		tx  = repository.transactionContext.PgTx
	)
	m := &models.OrderBase{
		Id: id,
	}
	_, err = tx.Model(m).
		Where("id=?", id).
		Where("company_id=?", companyId).
		Delete()
	return err
}