package dao

import (
	"fmt"
	"github.com/go-pg/pg/v10"
	"github.com/go-pg/pg/v10/orm"
	"gitlab.fjmaimaimai.com/mmm-go/partner/pkg/domain"
	"gitlab.fjmaimaimai.com/mmm-go/partner/pkg/infrastructure/pg/models"
	"gitlab.fjmaimaimai.com/mmm-go/partner/pkg/infrastructure/pg/transaction"
	. "gitlab.fjmaimaimai.com/mmm-go/partner/pkg/infrastructure/utils"
	"strings"
)

type PartnerInfoDao struct {
	transactionContext *transaction.TransactionContext
}

func (dao *PartnerInfoDao) Update(queryOptions map[string]interface{}) error {
	tx := dao.transactionContext.PgTx
	m := new(models.PartnerInfo)
	query := NewQuery(tx.Model(m), queryOptions)
	query.SetUpdate(`account=?`, "Account")
	query.SetUpdate(`password=?`, "Password")
	query.SetWhere(`id=?`, "Id")
	query.SetWhere(`account=?`, "oldAccount")
	if _, ok := queryOptions["Id"]; !ok {
		if _, ok := queryOptions["oldAccount"]; !ok {
			return fmt.Errorf(`error: miss param "Id"`)
		}
	}
	_, err := query.Update()
	return err
}

func (dao *PartnerInfoDao) PartnerStatic(queryOptions map[string]interface{}) (count int, err error) {
	tx := dao.transactionContext.PgTx
	m := new(models.PartnerInfo)
	query := NewQuery(tx.Model(m), queryOptions)

	query.ColumnExpr("count(*) count")
	if inPartnerIds, ok := queryOptions["inPartnerIds"]; ok {
		query.Where("id in (?)", pg.In(inPartnerIds.([]int64)))
	}
	if inPartnerCategory, ok := queryOptions["inPartnerCategory"]; ok {
		query.Where(`partner_info.partner_category_infos @>'[{"id":?}]'`, inPartnerCategory)
	}
	// 多个合伙人类型
	if inPartnerCategory, ok := queryOptions["inPartnerCategories"]; ok {
		query.Query = query.WhereGroup(func(q *orm.Query) (*orm.Query, error) {
			if arrayInPartnerCategory, ok := inPartnerCategory.([]int64); ok {
				for i := range arrayInPartnerCategory {
					q.WhereOr(`partner_info.partner_category_infos @>'[{"id":?}]')`, arrayInPartnerCategory[i])
				}
			}
			return q, nil
		})
	}
	err = query.Select(&count)
	return
}

func (dao *PartnerInfoDao) Partners(partnerIds []int64, queryOptions map[string]interface{}) (statics []*domain.PartnerStatics, err error) {
	tx := dao.transactionContext.PgDd
	var sql = strings.Builder{}
	var filterPartners = strings.Builder{}

	if districts, ok := queryOptions["districts"]; ok {
		districts, ok := districts.([]string)
		if ok && len(districts) > 0 {
			var filterDistricts = strings.Builder{}
			for i := range districts {
				filterDistricts.WriteString(fmt.Sprintf(` region_info  @>'{"regionName":"%v"}'`, districts[i]))
				if i != (len(districts) - 1) {
					filterDistricts.WriteString(" or ")
				}
			}
			filterPartners.WriteString(fmt.Sprintf(" and (%v)", filterDistricts.String()))
		}
	}
	if joinWays, ok := queryOptions["joinWays"]; ok {
		joinWays, ok := joinWays.([]int64)
		if ok && len(joinWays) > 0 {
			var filterJoinWays = strings.Builder{}
			for i := range joinWays {
				filterJoinWays.WriteString(fmt.Sprintf(` partner_category_infos  @>'[{"id":%v}]'`, joinWays[i]))
				if i != (len(joinWays) - 1) {
					filterJoinWays.WriteString(" or ")
				}
			}
			filterPartners.WriteString(fmt.Sprintf(" and (%v)", filterJoinWays.String()))
		}
	}
	if startTime, ok := queryOptions["startTime"]; ok {
		filterPartners.WriteString(fmt.Sprintf(" and cooperate_time>=to_timestamp(%v)", startTime))
	}
	if endTime, ok := queryOptions["endTime"]; ok {
		filterPartners.WriteString(fmt.Sprintf(" and cooperate_time<to_timestamp(%v)", endTime))
	}
	if keyword, ok := queryOptions["keyword"]; ok {
		filterPartners.WriteString(fmt.Sprintf(" and partner_name LIKE %v", keyword))
	}

	sql.WriteString(fmt.Sprintf(`
SELECT  A.*,B.total,B.amount,COALESCE(B.bonus,0) bonus,B.bonus_expense
FROM 
(
	SELECT * FROM partner_info
	WHERE (id in (?))  %v
) 
A left join 
(
	SELECT partner_id,count(*) total,sum(amount) amount,sum(bonus) bonus,sum(bonus_expense) bonus_expense FROM
		(
			SELECT partner_id,
			plan_order_amount  amount, 
			(case when use_order_count>=0 then use_partner_bonus else plan_partner_bonus end) bonus,
			partner_bonus_expense bonus_expense FROM "order_base" AS "order_base" 
			WHERE (partner_id in (?)) and (order_type in (?))
			UNION ALL
			SELECT partner_info_id partner_id,
			0 amount, bonus bonus, bonus_expense bonus_expense FROM business_bonus
			WHERE (partner_info_id in (?)) and is_disable=1
		) B
GROUP BY partner_id
) B on A."id" = B.partner_id`, filterPartners.String()))
	if sortByBonus, ok := queryOptions["sortByBonus"]; ok {
		sql.WriteString(fmt.Sprintf(" \norder by bonus %v", sortByBonus))
	}
	if limit, ok := queryOptions["limit"]; ok {
		sql.WriteString(fmt.Sprintf(" \nLIMIT %v", limit))
		if offset, ok := queryOptions["offset"]; ok {
			sql.WriteString(fmt.Sprintf(" \nOFFSET %v", offset))
		}
	}
	_, err = tx.Query(&statics, sql.String(), pg.In(partnerIds), pg.In(partnerIds), pg.In(domain.UserOrderTypes(domain.Career)), pg.In(partnerIds))
	return
}

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