package tysk

import (
	"gitea.cdlsxd.cn/self-tools/tysk/tysk_constant"
	"gitea.cdlsxd.cn/self-tools/tysk/tysk_entity"
)

type Tysk struct {
	UserName string // 用户名
	Env      string // 环境,测试：dev,不传默认正式
}

func NewTysk(userName string, opts ...Option) TyskFacade {
	tysk := &Tysk{UserName: userName}
	for _, opt := range opts {
		opt(tysk) // 应用选项
	}
	return tysk
}

type Option func(*Tysk)

func WithEnvTest() Option {
	return func(tysk *Tysk) {
		tysk.Env = "dev"
	}
}

func (g *Tysk) GetAccountBalance(accountList tysk_entity.GetAccountBalanceReq) (res map[tysk_constant.AccountNo]tysk_entity.GetAccountBalanceList, err error) {
	var result tysk_entity.AccountBalance

	err = g.handleRequest(tysk_constant.GetAccountBalance, g.handleReqStructToMap(accountList), &result)
	if err != nil {
		return
	}
	res = make(map[tysk_constant.AccountNo]tysk_entity.GetAccountBalanceList, len(result.List.Row))
	for _, row := range result.List.Row {
		res[row.AccountNo] = row
	}
	return
}

func (g *Tysk) GetTodayTransHis(todayTransHisReq tysk_entity.TodayTransHisReq) (res tysk_entity.TodayTransHisResp, err error) {
	err = g.handleRequest(tysk_constant.GetTodayTransHis, g.handleReqStructToMap(todayTransHisReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) GetAccountInfo(accountInfoReq tysk_entity.AccountInfoReq) (res tysk_entity.AccountInfoResp, err error) {
	err = g.handleRequest(tysk_constant.GetAccountInfo, g.handleReqStructToMap(accountInfoReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) ReceiptApply(receiptApplyReq tysk_entity.ReceiptApplyReq) (success bool, err error) {
	err = g.handleRequest(tysk_constant.ReceiptApply, g.handleReqStructToMap(receiptApplyReq), nil)
	if err != nil {
		return
	}
	return true, nil
}

func (g *Tysk) ReceiptQuery(receiptQueryReq tysk_entity.ReceiptQueryReq) (res tysk_entity.ReceiptQueryResp, err error) {
	err = g.handleRequest(tysk_constant.ReceiptQuery, g.handleReqStructToMap(receiptQueryReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) ReceiptDownload(receiptDownloadReq tysk_entity.ReceiptDownloadReq) (res tysk_entity.ReceiptDownloadResp, err error) {
	err = g.handleRequest(tysk_constant.ReceiptDownload, g.handleReqStructToMap(receiptDownloadReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) TransHisQueryApply(TransHisQueryApplyReq tysk_entity.TransHisQueryApplyReq) (res tysk_entity.TransHisQueryApplyResp, err error) {
	err = g.handleRequest(tysk_constant.TransHisQueryApply, g.handleReqStructToMap(TransHisQueryApplyReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) TransHisQuery(transHisReq tysk_entity.TransHisQueryReq) (res tysk_entity.TransHisQueryResp, err error) {
	err = g.handleRequest(tysk_constant.TransHisQuery, g.handleReqStructToMap(transHisReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) BalanceHisQueryApply(BalanceHisQueryApplyReq tysk_entity.BalanceHisQueryApplyReq) (res tysk_entity.BalanceHisQueryApplyResp, err error) {
	err = g.handleRequest(tysk_constant.BalanceHisQueryApply, g.handleReqStructToMap(BalanceHisQueryApplyReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) BalanceHisQuery(BalanceHisQueryReq tysk_entity.BalanceHisQueryReq) (res tysk_entity.BalanceHisQueryResp, err error) {
	err = g.handleRequest(tysk_constant.BalanceHisQuery, g.handleReqStructToMap(BalanceHisQueryReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) AccountsTransHisQuery(AccountsTransHisQueryReq tysk_entity.AccountsTransHisQueryReq) (res tysk_entity.AccountsTransHisQueryResp, err error) {
	err = g.handleRequest(tysk_constant.AccountsTransHisQuery, g.handleReqStructToMap(AccountsTransHisQueryReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) SinglePay(singlePayReq tysk_entity.SinglePayReq) (res tysk_entity.SinglePayResp, err error) {
	err = g.handleRequest(tysk_constant.SinglePay, g.handleReqStructToMap(singlePayReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) SinglePayQuery(singlePayQueryReq tysk_entity.SinglePayQueryReq) (res tysk_entity.SinglePayQueryResp, err error) {
	err = g.handleRequest(tysk_constant.SinglePayQuery, g.handleReqStructToMap(singlePayQueryReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) BatchPay(batchPayReq tysk_entity.BatchPayReq) (res tysk_entity.BatchPayResp, err error) {
	err = g.handleRequest(tysk_constant.BatchPay, g.handleReqStructToMap(batchPayReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) BatchPayQuery(batchPayQueryReq tysk_entity.BatchPayQueryReq) (res tysk_entity.BatchPayQueryResp, err error) {
	err = g.handleRequest(tysk_constant.BatchPayQueryReq, g.handleReqStructToMap(batchPayQueryReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) PayArrange(payArrangeReq tysk_entity.PayArrangeReq) (success bool, err error) {
	err = g.handleRequest(tysk_constant.PayArrangeReq, g.handleReqStructToMap(payArrangeReq), nil)
	if err != nil {
		return
	}
	return true, nil
}