package telecom

import (
	"bytes"
	"context"
	"crypto/des"
	"errors"
	"fmt"
	"math/rand"
	"strconv"
	"time"

	"go-common/app/interface/main/app-wall/model/telecom"
	"go-common/library/ecode"
	"go-common/library/log"
	"go-common/library/sync/errgroup"
)

const (
	_sendSMSCaptcha = `{"captcha":"%v"}`
	_sendSMSFlow    = `{"flow":"%v"}`
	_flowPackageID  = 279
)

// InOrdersSync insert OrdersSync
func (s *Service) InOrdersSync(c context.Context, ip string, u *telecom.TelecomOrderJson) (err error) {
	if !s.iplimit(_telecomKey, ip) {
		err = ecode.AccessDenied
		return
	}
	if u == nil || u.Detail == nil {
		err = ecode.NothingFound
		return
	}
	var (
		result    int64
		requestNo int
		phoneStr  string
		detail    = u.Detail
	)
	detail.TelecomJSONChange()
	requestNo, _ = strconv.Atoi(u.RequestNo)
	if detail.PhoneID == "" {
		if phoneStr, err = s.dao.PayPhone(c, int64(requestNo)); err != nil {
			log.Error("telecom_s.dao.PayPhone error(%v)", err)
			return
		}
	} else {
		phoneStr = detail.PhoneID
	}
	if result, err = s.dao.InOrderSync(c, requestNo, u.ResultType, phoneStr, detail); err != nil || result == 0 {
		log.Error("telecom_s.dao.OrdersSync (%v) error(%v) or result==0", u, err)
		return
	}
	if detail.OrderStatus == 3 {
		phoneInt, _ := strconv.Atoi(phoneStr)
		if err = s.dao.SendTelecomSMS(c, phoneInt, s.smsOrderTemplateOK); err != nil {
			log.Error("telecom_s.dao.SendTelecomSMS error(%v)", err)
			return
		}
	}
	return
}

// InRechargeSync insert RechargeSync
func (s *Service) InRechargeSync(c context.Context, ip string, u *telecom.RechargeJSON) (err error) {
	if !s.iplimit(_telecomKey, ip) {
		err = ecode.AccessDenied
		return
	}
	var result int64
	if result, err = s.dao.InRechargeSync(c, u); err != nil || result == 0 {
		log.Error("telecom_s.dao.InRechargeSync (%v) error(%v) or result==0", u, err)
		return
	}
	return
}

// telecomMessageOrder
func (s *Service) TelecomMessageSync(c context.Context, ip string, u *telecom.TelecomMessageJSON) (err error) {
	if !s.iplimit(_telecomKey, ip) {
		err = ecode.AccessDenied
		return
	}
	if u == nil {
		err = ecode.ServerErr
		return
	}
	phoneInt, _ := strconv.Atoi(u.PhoneID)
	if err = s.dao.SendTelecomSMS(c, phoneInt, s.smsMsgTemplate); err != nil {
		log.Error("telecom_s.dao.SendTelecomSMS error(%v)", err)
		return
	}
	return
}

// telecomInfo
func (s *Service) telecomInfo(c context.Context, phone int) (res map[int]*telecom.OrderInfo, err error) {
	var (
		row *telecom.OrderInfo
	)
	res = map[int]*telecom.OrderInfo{}
	if row, err = s.dao.TelecomCache(c, phone); err == nil && row != nil {
		res[phone] = row
		s.pHit.Incr("telecom_cache")
		return
	}
	if res, err = s.dao.OrdersUserFlow(c, phone); err != nil {
		log.Error("telecom_s.dao.OrdersUserFlow phone (%v) error(%v)", phone, err)
		return
	}
	s.pMiss.Incr("telecom_cache")
	if user, ok := res[phone]; ok {
		if err = s.dao.AddTelecomCache(c, phone, user); err != nil {
			log.Error("telecom_s.dao.AddTelecomCache error(%v)", err)
			return
		}
	}
	return
}

// telecomInfoByOrderID
func (s *Service) telecomInfoByOrderID(c context.Context, orderID int64) (res map[int64]*telecom.OrderInfo, err error) {
	var (
		row *telecom.OrderInfo
	)
	res = map[int64]*telecom.OrderInfo{}
	if row, err = s.dao.TelecomOrderIDCache(c, orderID); err == nil && row != nil {
		res[orderID] = row
		s.pHit.Incr("telecom_orderid_cache")
		return
	}
	if res, err = s.dao.OrdersUserByOrderID(c, orderID); err != nil {
		log.Error("telecom_s.dao.OrdersUserByOrderID phone (%v) error(%v)", orderID, err)
		return
	}
	s.pMiss.Incr("telecom_orderid_cache")
	if user, ok := res[orderID]; ok {
		if err = s.dao.AddTelecomOrderIDCache(c, orderID, user); err != nil {
			log.Error("telecom_s.dao.AddTelecomOrderIDCache error(%v)", err)
			return
		}
	}
	return
}

// TelecomPay
func (s *Service) TelecomPay(c context.Context, phone, isRepeatOrder, payChannel, payAction int, orderID int64, ipStr string) (res *telecom.Pay, msg string, err error) {
	var (
		requestNo         int64
		t                 map[int]*telecom.OrderInfo
		rcode             int
		beginTime         time.Time
		firstOrderEndtime time.Time
	)
	if requestNo, err = s.seqdao.SeqID(c); err != nil {
		log.Error("telecom_s.seqdao.SeqID error (%v)", err)
		return
	}
	if t, err = s.telecomInfo(c, phone); err != nil {
		log.Error("telecom_s.telecomInfo phone(%v) error (%v)", phone, err)
		return
	}
	if user, ok := t[phone]; ok {
		beginTime = user.Begintime.Time()
		firstOrderEndtime = user.Endtime.Time()
	}
	if res, err, msg = s.dao.PayInfo(c, requestNo, phone, isRepeatOrder, payChannel, payAction, orderID, ipStr, beginTime, firstOrderEndtime); err != nil || res == nil {
		log.Error("telecom_s.dao.PayInfo requestNo (%v) phone (%v) isRepeatOrder (%v) payChannel (%v) payAction (%v) t.OrderID (%v) ipStr (%v) error (%v)",
			requestNo, phone, isRepeatOrder, payChannel, payAction, orderID, ipStr, err)
		return
	}
	phoneStr := strconv.Itoa(phone)
	if rcode, err = s.dao.AddPayPhone(c, requestNo, phoneStr); err != nil || rcode != 1 {
		log.Error("telecom_s.dao.AddPayPhone error (%v)", err)
		return
	}
	return
}

// CancelRepeatOrder
func (s *Service) CancelRepeatOrder(c context.Context, phone int) (msg string, err error) {
	var (
		res map[int]*telecom.OrderInfo
	)
	res, err = s.telecomInfo(c, phone)
	if err != nil {
		log.Error("telecom_s.telecomInfo phone(%v) error (%v)", phone, err)
		return
	}
	user, ok := res[phone]
	if !ok {
		err = ecode.NothingFound
		msg = "订单不存在"
		return
	}
	if msg, err = s.dao.CancelRepeatOrder(c, phone, user.SignNo); err != nil {
		log.Error("telecom_s.dao.CancelRepeatOrder phone(%v) signNo(%v) error (%v)", phone, user.SignNo, err)
		return
	}
	return
}

// OrderList user order list
func (s *Service) OrderList(c context.Context, orderID int64, phone int) (res *telecom.SucOrder, msg string, err error) {
	if res, err, msg = s.dao.SucOrderList(c, phone); err != nil || res == nil {
		log.Error("telecom_s.dao.SucOrderList orderID (%v) phone (%v) error (%v)", orderID, phone, err)
		return
	}
	return
}

// PhoneFlow user flow
func (s *Service) PhoneFlow(c context.Context, orderID int64, phone int) (res *telecom.OrderFlow, msg string, err error) {
	var t *telecom.SucOrder
	if t, err, msg = s.dao.SucOrderList(c, phone); err != nil || t == nil {
		log.Error("telecom_s.dao.SucOrderList orderID (%v) phone (%v) error (%v)", orderID, phone, err)
		return
	}
	res = &telecom.OrderFlow{
		FlowBalance: t.FlowBalance,
	}
	if (t.FlowBalance/t.FlowPackageSize)*100 < s.flowPercentage {
		flow := strconv.Itoa(t.FlowBalance)
		dataJSON := fmt.Sprintf(_sendSMSFlow, flow)
		if err = s.dao.SendSMS(c, phone, s.smsFlowTemplate, dataJSON); err != nil {
			log.Error("telecom_s.dao.SendSMS phone(%v) error (%v)", phone, err)
			return
		}
		msg = "免流量量剩余不不⾜足10%，超出部分会按正常流量量资费计费"
		return
	}
	return
}

// OrderConsent user orderConsent
func (s *Service) OrderConsent(c context.Context, phone int, orderID int64, captcha string) (res *telecom.PhoneConsent, msg string, err error) {
	var (
		area       string
		t          *telecom.SucOrder
		captchaStr string
		order      *telecom.OrderPhoneState
	)
	captchaStr, err = s.dao.PhoneCode(c, phone)
	if err != nil {
		log.Error("telecom_s.dao.PhoneCode error (%v)", err)
		msg = "验证码已过期"
		return
	}
	if captchaStr == "" || captchaStr != captcha {
		err = ecode.NotModified
		msg = "验证码错误"
		return
	}
	res = &telecom.PhoneConsent{
		Consent: 0,
	}
	g, ctx := errgroup.WithContext(c)
	g.Go(func() error {
		if area, err, msg = s.dao.PhoneArea(ctx, phone); err != nil {
			log.Error("telecom_s.dao.PhoneArea phone(%v) error (%v)", phone, err)
			return err
		}
		return nil
	})
	g.Go(func() error {
		if t, err, _ = s.dao.SucOrderList(ctx, phone); err != nil {
			if err == ecode.NothingFound {
				err = nil
			} else {
				log.Error("telecom_s.dao.SucOrderList sphone (%v) error (%v)", phone, err)
			}
			return err
		}
		return nil
	})
	if orderID > 0 {
		g.Go(func() error {
			if order, err = s.dao.OrderState(ctx, orderID); err != nil {
				log.Error("telecom_s.dao.OrderState phone(%v) orderID(%v) error(%v)", phone, orderID, err)
				return err
			}
			return nil
		})
	}
	if err = g.Wait(); err != nil {
		log.Error("telecom_errgroup.WithContext error(%v)", err)
		return
	}
	if len(area) >= 4 {
		a := area[:4]
		if _, ok := s.telecomArea[a]; !ok {
			return
		}
	}
	if order != nil && order.OrderState == 2 && order.FlowPackageID == _flowPackageID {
		res.Consent = 3
		return
	}
	if t != nil && t.OrderID > 0 {
		res.Consent = 2
		return
	}
	res.Consent = 1
	return
}

// PhoneCode
func (s *Service) PhoneCode(c context.Context, phone int, captcha string, now time.Time) (res *telecom.Pay, err error, msg string) {
	var (
		captchaStr string
		order      map[int]*telecom.OrderInfo
	)
	captchaStr, err = s.dao.PhoneCode(c, phone)
	if err != nil {
		log.Error("telecom_s.dao.PhoneCode error (%v)", err)
		msg = "验证码已过期"
		return
	}
	if captchaStr == "" || captchaStr != captcha {
		err = ecode.NotModified
		msg = "验证码错误"
		return
	}
	if order, err = s.telecomInfo(c, phone); err != nil {
		log.Error("telecom_s.telecomInfo phone(%v) error (%v)", phone, err)
		return
	}
	user, ok := order[phone]
	if !ok {
		err = ecode.NothingFound
		msg = "订单不存在"
		return
	}
	switch user.OrderState {
	case 2:
		err = ecode.NotModified
		msg = "订购中"
	case 3:
		if now.Unix() > int64(user.Endtime) {
			err = ecode.NotModified
			msg = "订单已过期"
		} else {
			res = &telecom.Pay{
				OrderID: user.OrderID,
			}
			msg = "激活成功，麻麻再也不不⽤用担⼼心我的流量量了了(/≧▽≦)/"
		}
	case 4:
		err = ecode.NotModified
		msg = "订单失败"
	case 5:
		err = ecode.NotModified
		msg = "订单已过期"
	}
	return
}

// PhoneSendSMS
func (s *Service) PhoneSendSMS(c context.Context, phone int) (err error) {
	var (
		captcha string
		rcode   int
	)
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	for i := 0; i < 6; i++ {
		captcha = captcha + strconv.Itoa(r.Intn(10))
	}
	dataJSON := fmt.Sprintf(_sendSMSCaptcha, captcha)
	if err = s.dao.SendSMS(c, phone, s.smsTemplate, dataJSON); err != nil {
		log.Error("telecom_s.dao.SendSMS error (%v)", err)
		return
	}
	if rcode, err = s.dao.AddPhoneCode(c, phone, captcha); err != nil || rcode != 1 {
		log.Error("telecom_s.dao.AddPhoneCode error (%v)", err)
		return
	}
	return
}

// OrderState
func (s *Service) OrderState(c context.Context, orderid int64) (t *telecom.OrderState, msg string, err error) {
	var (
		orderState *telecom.OrderPhoneState
		torder     map[int64]*telecom.OrderInfo
		userOrder  *telecom.OrderInfo
		tSucOrder  *telecom.SucOrder
		ok         bool
	)
	g, ctx := errgroup.WithContext(c)
	log.Error("userOrder.PhoneID_test")
	g.Go(func() error {
		if orderState, err = s.dao.OrderState(ctx, orderid); err != nil {
			log.Error("telecom_s.dao.OrderState orderID error(%v)", orderid, err)
			return err
		}
		return nil
	})
	g.Go(func() error {
		if torder, err = s.telecomInfoByOrderID(c, orderid); err != nil {
			log.Error("telecom_s.telecomInfoByOrderID error(%v)", orderid, err)
			return err
		}
		if userOrder, ok = torder[orderid]; ok {
			if tSucOrder, err, _ = s.dao.SucOrderList(ctx, userOrder.PhoneID); err != nil {
				if err == ecode.NothingFound {
					err = nil
				} else {
					log.Error("telecom_s.dao.SucOrderList sphone (%v) error (%v)", userOrder.PhoneID, err)
				}
				return err
			}
		}
		return nil
	})
	if err = g.Wait(); err != nil {
		log.Error("telecom_errgroup.WithContext error(%v)", err)
		return
	}
	if orderState == nil {
		t = &telecom.OrderState{
			OrderState: 1,
		}
		return
	}
	t = &telecom.OrderState{
		OrderState: orderState.OrderState,
		FlowSize:   orderState.FlowSize,
	}
	if tSucOrder != nil && tSucOrder.OrderID > 0 {
		t.FlowBalance = tSucOrder.FlowBalance
		t.FlowSize = tSucOrder.FlowPackageSize
	}
	if ok {
		t.IsRepeatorder = userOrder.IsRepeatorder
		if userOrder.IsRepeatorder == 0 {
			t.Endtime = userOrder.Endtime
		}
	}
	switch t.OrderState {
	case 6:
		if !ok {
			err = ecode.NothingFound
			msg = "订单不存在"
			return
		}
		t.Endtime = userOrder.Endtime
	}
	return
}

// telecomIp ip limit
func (s *Service) iplimit(k, ip string) bool {
	key := fmt.Sprintf(_initIPlimitKey, k, ip)
	if _, ok := s.operationIPlimit[key]; ok {
		return true
	}
	return false
}

// DesDecrypt
func (s *Service) DesDecrypt(src, key []byte) ([]byte, error) {
	block, err := des.NewCipher(key)
	if err != nil {
		return nil, err
	}
	out := make([]byte, len(src))
	dst := out
	bs := block.BlockSize()
	if len(src)%bs != 0 {
		return nil, errors.New("crypto/cipher: input not full blocks")
	}
	for len(src) > 0 {
		block.Decrypt(dst, src[:bs])
		src = src[bs:]
		dst = dst[bs:]
	}
	out = s.zeroUnPadding(out)
	return out, nil
}

// zeroUnPadding
func (s *Service) zeroUnPadding(origData []byte) []byte {
	return bytes.TrimFunc(origData,
		func(r rune) bool {
			return r == rune(0)
		})
}