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 OrderRepository struct {
	transactionContext *transaction.TransactionContext
}

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

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

func (reponsitory OrderRepository) transformPgModelToDomainModel(orderModel *models.Order) (domain.Order, error) {
	result := domain.Order{
		Id:                 orderModel.Id,
		OrderType:          orderModel.OrderType,
		OrderCode:          orderModel.OrderCode,
		OrderName:          orderModel.OrderName,
		OrderStatus:        orderModel.OrderStatus,
		OrderCount:         orderModel.OrderCount,
		OrderActualCount:   orderModel.OrderActualCount,
		OrderAmount:        orderModel.OrderAmount,
		OrderActualAmount:  orderModel.OrderActualAmount,
		OrderPaymentAmount: orderModel.OrderPaymentAmount,
		OrderRegionInfo:    orderModel.OrderRegionInfo,
		Buyer:              orderModel.Buyer,
		PartnerInfo: domain.Partner{
			Id: orderModel.PartnerId,
		},
		PartnerBonusPercent:  orderModel.PartnerBonusPercent,
		SalesmanBonusPercent: orderModel.SalesmanBonusPercent,
		LastViewTime:         orderModel.LastViewTime,
		UpdateAt:             orderModel.UpdateAt,
		CreateAt:             orderModel.CreateAt,
		Reason:               orderModel.Reason,
	}
	return result, nil
}

func (repository OrderRepository) Save(orderInfo domain.Order) error {
	var (
		err error
		tx  = repository.transactionContext.PgTx
	)
	m := &models.Order{
		Id:                   orderInfo.Id,
		OrderType:            orderInfo.OrderType,
		OrderCode:            orderInfo.OrderCode,
		OrderName:            orderInfo.OrderName,
		OrderStatus:          orderInfo.OrderStatus,
		OrderCount:           orderInfo.OrderCount,
		OrderActualCount:     orderInfo.OrderActualCount,
		OrderAmount:          orderInfo.OrderAmount,
		OrderActualAmount:    orderInfo.OrderActualAmount,
		OrderPaymentAmount:   orderInfo.OrderPaymentAmount,
		OrderRegionInfo:      orderInfo.OrderRegionInfo,
		Buyer:                orderInfo.Buyer,
		PartnerId:            orderInfo.PartnerInfo.Id,
		PartnerBonusPercent:  orderInfo.PartnerBonusPercent,
		SalesmanBonusPercent: orderInfo.SalesmanBonusPercent,
		BonusStatus:          1,
		Reason:               orderInfo.Reason,
	}
	if m.Id == 0 {
		err = tx.Insert(m)
		orderInfo.Id = m.Id
	} else {
		_, err = tx.Model(m).WherePK().
			Column("order_type", "order_code", "order_name", "order_status", "order_count",
				"order_actual_count", "order_amount", "order_actual_amount", "order_payment_amount",
				"order_region_info", "buyer", "partner_id", "partner_bonus_percent", "salesman_bonus_percent",
				"update_at", "reason").
			Update()
	}
	return err
}

func (repository OrderRepository) Find(queryOption domain.OrderFindQuery) ([]domain.Order, error) {
	db := repository.transactionContext.PgDd
	orderModels := []models.Order{}
	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 queryOption.OrderType > 0 {
		query = query.Where("order_type=?", queryOption.OrderType)
	}
	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.Order, 0)
	)
	query = query.Order("order.id DESC")
	err = query.Select()
	if err != nil {
		return ordersReturn, err
	}
	for i := range orderModels {
		domainOrder, err := repository.transformPgModelToDomainModel(&orderModels[i])
		if err != nil {
			return ordersReturn, err
		}
		ordersReturn = append(ordersReturn, domainOrder)
	}
	return ordersReturn, nil
}

func (repository OrderRepository) CountAll(queryOption domain.OrderFindQuery) (int, error) {
	db := repository.transactionContext.PgDd
	orderModels := []models.Order{}
	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 queryOption.OrderType > 0 {
		query = query.Where("order_type=?", queryOption.OrderType)
	}
	var (
		err error
	)
	cnt, err := query.Count()
	if err != nil {
		return cnt, err
	}
	return cnt, nil
}

func (repository OrderRepository) FindOne(qureyOptions domain.OrderFindOneQuery) (*domain.Order, error) {
	var (
		err error
		tx  = repository.transactionContext.PgDd
	)
	m := new(models.Order)
	err = tx.Model(m).
		Where("id=?", qureyOptions.OrderId).
		First()
	if err != nil {
		return nil, err
	}
	result, err := repository.transformPgModelToDomainModel(m)
	return &result, err
}

func (repository OrderRepository) Remove(id int64) error {
	var (
		err error
		tx  = repository.transactionContext.PgTx
	)
	m := &models.Order{
		Id: id,
	}
	_, err = tx.Model(m).WherePK().Delete()
	return err
}