package services

import (
	"encoding/json"
	"fmt"
	"platform/pkg/u"
	"platform/web/core"
	g "platform/web/globals"
	m "platform/web/models"
	q "platform/web/queries"
	"time"

	"github.com/shopspring/decimal"
)

var Resource = &resourceService{}

type resourceService struct{}

func (s *resourceService) CreateResourceByBalance(uid int32, now time.Time, data *CreateResourceData) error {
	return g.Redsync.WithLock(userBalanceKey(uid), func() error {
		return q.Q.Transaction(func(q *q.Query) error {
			// 找到用户
			user, err := q.User.
				Where(q.User.ID.Eq(uid)).
				Take()
			if err != nil {
				return err
			}

			// 检查余额
			var amount = user.Balance.Sub(data.GetAmount())
			if amount.IsNegative() {
				return ErrBalanceNotEnough
			}

			// 更新用户余额
			_, err = q.User.
				Where(q.User.ID.Eq(uid), q.User.Balance.Eq(user.Balance)).
				UpdateSimple(q.User.Balance.Value(amount))
			if err != nil {
				return core.NewServErr("更新用户余额失败", err)
			}

			// 保存套餐
			resource, err := createResource(q, uid, now, data)
			if err != nil {
				return core.NewServErr("创建套餐失败", err)
			}

			// 生成账单
			err = q.Bill.Create(newForConsume(uid, Bill.GenNo(), data.GetSubject(), data.GetAmount(), resource))
			if err != nil {
				return core.NewServErr("生成账单失败", err)
			}

			return nil
		})
	})
}

func (s *resourceService) CreateResourceByTrade(uid int32, now time.Time, data *CreateResourceData, trade *m.Trade) error {
	return q.Q.Transaction(func(q *q.Query) error {

		// 保存套餐
		resource, err := createResource(q, uid, now, data)
		if err != nil {
			return core.NewServErr("创建套餐失败", err)
		}

		// 生成账单
		err = q.Bill.Create(newForConsume(uid, Bill.GenNo(), data.GetSubject(), data.GetAmount(), resource, trade))
		if err != nil {
			return core.NewServErr("生成账单失败", err)
		}

		return nil
	})
}

func createResource(q *q.Query, uid int32, now time.Time, data *CreateResourceData) (*m.Resource, error) {

	// 套餐基本信息
	var resource = m.Resource{
		UserID:     uid,
		ResourceNo: u.P(ID.GenReadable("res")),
		Active:     true,
		Type:       data.Type,
	}
	switch data.Type {

	// 短效套餐
	case m.ResourceTypeShort:
		var short = data.Short
		if short == nil {
			return nil, core.NewBizErr("短效套餐数据不能为空")
		}
		var duration = time.Duration(short.Expire) * 24 * time.Hour
		resource.Short = &m.ResourceShort{
			Type:       short.Mode,
			Live:       short.Live,
			Quota:      &short.Quota,
			Expire:     u.P(now.Add(duration)),
			DailyLimit: short.DailyLimit,
		}

	// 长效套餐
	case m.ResourceTypeLong:
		var long = data.Long
		if long == nil {
			return nil, core.NewBizErr("长效套餐数据不能为空")
		}
		var duration = time.Duration(long.Expire) * 24 * time.Hour
		resource.Long = &m.ResourceLong{
			Type:       long.Mode,
			Live:       long.Live,
			Quota:      &long.Quota,
			Expire:     u.P(now.Add(duration)),
			DailyLimit: long.DailyLimit,
		}
	default:
		return nil, core.NewBizErr("不支持的套餐类型")
	}

	err := q.Resource.Create(&resource)
	if err != nil {
		return nil, core.NewServErr("创建套餐失败", err)
	}

	return &resource, nil
}

type CreateResourceData struct {
	Type  m.ResourceType           `json:"type" validate:"required"`
	Short *CreateShortResourceData `json:"short,omitempty"`
	Long  *CreateLongResourceData  `json:"long,omitempty"`
}

type CreateShortResourceData struct {
	Live       int32          `json:"live" validate:"required,min=180"`
	Mode       m.ResourceMode `json:"mode" validate:"required"`
	Expire     int32          `json:"expire"`
	DailyLimit int32          `json:"daily_limit" validate:"min=2000"`
	Quota      int32          `json:"quota" validate:"min=10000"`

	name  string
	price *decimal.Decimal
}

type CreateLongResourceData struct {
	Live       int32          `json:"live" validate:"required,oneof=1 4 8 12 24"`
	Mode       m.ResourceMode `json:"mode" validate:"required,oneof=1 2"`
	Expire     int32          `json:"expire"`
	DailyLimit int32          `json:"daily_limit" validate:"min=100"`
	Quota      int32          `json:"quota" validate:"min=500"`

	name  string
	price *decimal.Decimal
}

func (c *CreateResourceData) GetType() m.TradeType {
	return m.TradeTypePurchase
}

func (c *CreateResourceData) GetSubject() string {
	switch c.Type {
	case m.ResourceTypeShort:
		return c.Short.GetSubject()
	case m.ResourceTypeLong:
		return c.Long.GetSubject()
	}
	panic("类型对应的数据为空")
}

func (c *CreateResourceData) GetAmount() decimal.Decimal {
	switch c.Type {
	case m.ResourceTypeShort:
		return c.Short.GetAmount()
	case m.ResourceTypeLong:
		return c.Long.GetAmount()
	}
	panic("类型对应的数据为空")
}

func (c *CreateResourceData) Serialize() (string, error) {
	bytes, err := json.Marshal(c)
	return string(bytes), err
}

func (c *CreateResourceData) Deserialize(str string) error {
	return json.Unmarshal([]byte(str), c)
}

func (data *CreateShortResourceData) GetSubject() string {
	if data.name == "" {
		var mode string
		switch data.Mode {
		case 1:
			mode = "包时"
		case 2:
			mode = "包量"
		}
		data.name = fmt.Sprintf("短效动态%s %v 分钟", mode, data.Live/60)
	}
	return data.name
}

func (data *CreateShortResourceData) GetAmount() decimal.Decimal {
	if data.price == nil {
		var factor int32
		switch data.Mode {
		case 1:
			factor = data.DailyLimit * data.Expire
		case 2:
			factor = data.Quota
		}

		var base = data.Live
		if base == 180 {
			base = 150
		}

		var dec = decimal.Decimal{}.
			Add(decimal.NewFromInt32(base * factor)).
			Div(decimal.NewFromInt(30000))
		data.price = &dec
	}
	return *data.price
}

func (data *CreateLongResourceData) GetSubject() string {
	if data.name == "" {
		var mode string
		switch data.Mode {
		case 1:
			mode = "包时"
		case 2:
			mode = "包量"
		}
		data.name = fmt.Sprintf("长效动态%s %d 小时", mode, data.Live)
	}
	return data.name
}

func (data *CreateLongResourceData) GetAmount() decimal.Decimal {
	if data.price == nil {
		var factor int32 = 0
		switch data.Mode {

		case m.ResourceModeTime:
			factor = data.Expire * data.DailyLimit
		case m.ResourceModeQuota:
			factor = data.Quota
		}

		var base int32
		switch data.Live {
		case 1:
			base = 30
		case 4:
			base = 80
		case 8:
			base = 120
		case 12:
			base = 180
		case 24:
			base = 350
		}

		// data.price = big.NewRat(int64(base*factor), 100)
		var dec = decimal.Decimal{}.
			Add(decimal.NewFromInt32(base * factor)).
			Div(decimal.NewFromInt(100))
		data.price = &dec
	}
	return *data.price
}

type ResourceOnTradeComplete struct{}

func (r ResourceOnTradeComplete) Check(t m.TradeType) (ProductInfo, bool) {
	if t == m.TradeTypePurchase {
		return &CreateResourceData{}, true
	}
	return nil, false
}

func (r ResourceOnTradeComplete) OnTradeComplete(info ProductInfo, trade *m.Trade) error {
	return Resource.CreateResourceByTrade(trade.UserID, time.Time(*trade.CompletedAt), info.(*CreateResourceData), trade)
}

type ResourceServiceErr string

func (e ResourceServiceErr) Error() string {
	return string(e)
}

const (
	ErrBalanceNotEnough = ResourceServiceErr("余额不足")
)