package store

import (
	"context"
	"database/sql"
	"encoding/json"
	"errors"
	"time"

	"github.com/jmoiron/sqlx"
)

const (
	orderStatusMatching   = 1
	orderStatusPending    = 2
	orderStatusProcessing = 3
	orderStatusCompleted  = 4
	orderStatusExpired    = 5
	orderStatusFrozen     = 6
	orderStatusCancelled  = 7
	orderStatusFailed     = 8
)

type TaskHall struct {
	ID             int64  `db:"id"`
	Code           string `db:"hall_code"`
	Name           string `db:"name"`
	IconURL        string `db:"icon_url"`
	Summary        string `db:"summary"`
	CommissionRate int    `db:"commission_rate"`
	RateUnit       string `db:"rate_unit"`
	ClientRoute    string `db:"client_route"`
}

type TaskEligibility struct {
	MemberLevelID   int64 `db:"member_level_id"`
	MemberStatus    int   `db:"member_status"`
	HallEligible    bool  `db:"hall_eligible"`
	AvailableAmount int64 `db:"available_amount"`
	WalletStatus    int   `db:"wallet_status"`
	DailyLimit      int   `db:"daily_limit"`
	TodayCount      int   `db:"today_count"`
	PendingOrderID  int64 `db:"pending_order_id"`
}

type ClaimTaskInput struct {
	TenantID      int64
	MemberID      int64
	HallID        int64
	MinimumAmount int64
	DeadlineAt    time.Time
	OrderNo       string
}

type TaskOrder struct {
	ID               int64           `db:"id"`
	OrderNo          string          `db:"order_no"`
	TaskID           int64           `db:"task_id"`
	ProductID        int64           `db:"product_id"`
	ProductName      string          `db:"product_name"`
	CoverURL         string          `db:"cover_url"`
	Quantity         int             `db:"quantity"`
	UnitPriceAmount  int64           `db:"unit_price_amount"`
	TotalAmount      int64           `db:"total_amount"`
	CommissionAmount int64           `db:"commission_amount"`
	Currency         string          `db:"currency"`
	MemberLevelID    int64           `db:"member_level_id"`
	RuleSnapshot     json.RawMessage `db:"rule_snapshot"`
	Message          string          `db:"message"`
	OrderStatus      int             `db:"order_status"`
	FreezeStatus     int             `db:"freeze_status"`
	DeadlineAt       string          `db:"deadline_at"`
	MatchedAt        string          `db:"matched_at"`
	CompletedAt      string          `db:"completed_at"`
	CreatedAt        string          `db:"created_at"`
	UpdatedAt        string          `db:"updated_at"`
	TaskTitle        string          `db:"task_title"`
	TaskDescription  string          `db:"task_description"`
	TaskDetailHTML   string          `db:"task_detail_html"`
	SubmissionNo     string          `db:"submission_no"`
	SubmissionStatus int             `db:"submission_status"`
	EvidenceText     string          `db:"evidence_text"`
	EvidenceIDs      json.RawMessage `db:"evidence_attachment_ids"`
	ReviewReasonCode string          `db:"review_reason_code"`
	ReviewReason     string          `db:"review_reason"`
	AllowResubmit    int             `db:"allow_resubmit"`
	SubmittedAt      string          `db:"submitted_at"`
	ReviewedAt       string          `db:"reviewed_at"`
	SettledAt        string          `db:"settled_at"`
}

type TaskOrderPage struct {
	Items []TaskOrder
	Total int64
}

type TaskStats struct {
	AvailableAmount           int64 `db:"available_amount"`
	FrozenAmount              int64 `db:"frozen_amount"`
	TodayCommissionAmount     int64 `db:"today_commission_amount"`
	YesterdayCommissionAmount int64 `db:"yesterday_commission_amount"`
	TodayClaimCount           int   `db:"today_claim_count"`
	TodayCompletedCount       int   `db:"today_completed_count"`
}

type TaskSubmissionInput struct {
	TenantID      int64
	MemberID      int64
	OrderID       int64
	SubmissionNo  string
	EvidenceText  string
	AttachmentIDs []int64
}

type TaskSubmissionResult struct {
	SubmissionNo string `db:"submission_no"`
	OrderStatus  int
	SubmittedAt  time.Time
}

func (s *Store) TaskHalls(ctx context.Context, tenantID, memberID int64) ([]TaskHall, error) {
	rows := make([]TaskHall, 0)
	err := s.db.SelectContext(ctx, &rows, `SELECT h.id,h.hall_code,h.name,h.icon_url,h.summary,
		h.commission_rate,h.rate_unit,h.client_route FROM hg_task_hall h
		JOIN hg_app_member m ON m.tenant_id=h.tenant_id AND m.id=? AND m.member_status=1 AND m.deleted_at IS NULL
		JOIN hg_task_hall_level hl ON hl.tenant_id=h.tenant_id AND hl.hall_id=h.id AND hl.level_id=m.level_id
		WHERE h.tenant_id=? AND h.publish_status=3 AND h.deleted_at IS NULL ORDER BY h.sort,h.id`, memberID, tenantID)
	return rows, err
}

func (s *Store) TaskEligibility(ctx context.Context, tenantID, memberID, hallID int64) (*TaskEligibility, error) {
	var row TaskEligibility
	err := s.db.GetContext(ctx, &row, `SELECT m.level_id AS member_level_id,m.member_status,
		EXISTS(SELECT 1 FROM hg_task_hall h JOIN hg_task_hall_level hl
			ON hl.tenant_id=h.tenant_id AND hl.hall_id=h.id AND hl.level_id=m.level_id
			WHERE h.tenant_id=m.tenant_id AND h.id=? AND h.publish_status=3 AND h.deleted_at IS NULL) AS hall_eligible,
		COALESCE(w.available_amount,0) AS available_amount,COALESCE(w.account_status,0) AS wallet_status,
		COALESCE(lv.daily_order_limit,0) AS daily_limit,
		(SELECT COUNT(*) FROM hg_trade_order o WHERE o.tenant_id=m.tenant_id AND o.member_id=m.id
			AND o.order_type=2 AND o.created_at>=UTC_DATE() AND o.created_at<UTC_DATE()+INTERVAL 1 DAY) AS today_count,
		COALESCE((SELECT o2.id FROM hg_trade_order o2 WHERE o2.tenant_id=m.tenant_id AND o2.member_id=m.id
			AND o2.order_type=2 AND o2.order_status IN (1,2,3,6) ORDER BY o2.id DESC LIMIT 1),0) AS pending_order_id
		FROM hg_app_member m
		LEFT JOIN hg_app_member_level l ON l.tenant_id=m.tenant_id AND l.id=m.level_id AND l.status=1 AND l.deleted_at IS NULL
		LEFT JOIN hg_app_member_level_version lv ON lv.tenant_id=l.tenant_id AND lv.id=l.current_version_id AND lv.publish_status=3
		LEFT JOIN hg_wallet_account w ON w.tenant_id=m.tenant_id AND w.member_id=m.id AND w.currency='CNY'
		WHERE m.tenant_id=? AND m.id=? AND m.deleted_at IS NULL LIMIT 1`, hallID, tenantID, memberID)
	if errors.Is(err, sql.ErrNoRows) {
		return nil, ErrAccountNotFound
	}
	return &row, err
}

func (s *Store) ClaimTask(ctx context.Context, input ClaimTaskInput) (*TaskOrder, error) {
	tx, err := s.db.BeginTxx(ctx, nil)
	if err != nil {
		return nil, err
	}
	defer tx.Rollback()

	var member struct {
		LevelID int64 `db:"level_id"`
	}
	err = tx.GetContext(ctx, &member, `SELECT level_id FROM hg_app_member
		WHERE tenant_id=? AND id=? AND member_status=1 AND deleted_at IS NULL LIMIT 1 FOR UPDATE`, input.TenantID, input.MemberID)
	if errors.Is(err, sql.ErrNoRows) {
		return nil, ErrAccountNotFound
	}
	if err != nil {
		return nil, err
	}
	var hallCount int
	err = tx.GetContext(ctx, &hallCount, `SELECT COUNT(*) FROM hg_task_hall h
		JOIN hg_task_hall_level hl ON hl.tenant_id=h.tenant_id AND hl.hall_id=h.id AND hl.level_id=?
		WHERE h.tenant_id=? AND h.id=? AND h.publish_status=3 AND h.deleted_at IS NULL`, member.LevelID, input.TenantID, input.HallID)
	if err != nil {
		return nil, err
	}
	if hallCount == 0 {
		return nil, ErrLevelNotEligible
	}
	var wallet struct {
		AvailableAmount int64 `db:"available_amount"`
		Status          int   `db:"account_status"`
	}
	err = tx.GetContext(ctx, &wallet, `SELECT available_amount,account_status FROM hg_wallet_account
		WHERE tenant_id=? AND member_id=? AND currency='CNY' LIMIT 1 FOR UPDATE`, input.TenantID, input.MemberID)
	if errors.Is(err, sql.ErrNoRows) {
		return nil, ErrInsufficientBalance
	}
	if err != nil {
		return nil, err
	}
	if wallet.Status != 1 {
		return nil, ErrAccountRestricted
	}
	if wallet.AvailableAmount < input.MinimumAmount {
		return nil, ErrInsufficientBalance
	}
	var pending int64
	err = tx.GetContext(ctx, &pending, `SELECT id FROM hg_trade_order
		WHERE tenant_id=? AND member_id=? AND order_type=2 AND order_status IN (1,2,3,6)
		ORDER BY id DESC LIMIT 1 FOR UPDATE`, input.TenantID, input.MemberID)
	if err != nil && !errors.Is(err, sql.ErrNoRows) {
		return nil, err
	}
	if pending > 0 {
		return nil, ErrPendingOrderExists
	}
	var dailyLimit int
	err = tx.GetContext(ctx, &dailyLimit, `SELECT COALESCE(v.daily_order_limit,0) FROM hg_app_member_level l
		LEFT JOIN hg_app_member_level_version v ON v.tenant_id=l.tenant_id AND v.id=l.current_version_id AND v.publish_status=3
		WHERE l.tenant_id=? AND l.id=? AND l.status=1 AND l.deleted_at IS NULL LIMIT 1`, input.TenantID, member.LevelID)
	if errors.Is(err, sql.ErrNoRows) {
		return nil, ErrLevelNotEligible
	}
	if err != nil {
		return nil, err
	}
	if dailyLimit > 0 {
		var todayCount int
		if err := tx.GetContext(ctx, &todayCount, `SELECT COUNT(*) FROM hg_trade_order WHERE tenant_id=? AND member_id=?
			AND order_type=2 AND created_at>=UTC_DATE() AND created_at<UTC_DATE()+INTERVAL 1 DAY`, input.TenantID, input.MemberID); err != nil {
			return nil, err
		}
		if todayCount >= dailyLimit {
			return nil, ErrDailyLimitReached
		}
	}
	var task struct {
		ID               int64  `db:"id"`
		Title            string `db:"title"`
		CoverURL         string `db:"cover_url"`
		CommissionAmount int64  `db:"commission_amount"`
		CommissionRate   int    `db:"commission_rate"`
		PerMemberLimit   int    `db:"per_member_limit"`
	}
	err = tx.GetContext(ctx, &task, `SELECT t.id,t.title,t.cover_url,t.commission_amount,t.commission_rate,t.per_member_limit
		FROM hg_task t JOIN hg_task_level tl ON tl.tenant_id=t.tenant_id AND tl.task_id=t.id AND tl.level_id=?
		WHERE t.tenant_id=? AND t.hall_id=? AND t.publish_status=3 AND t.deleted_at IS NULL
		AND (t.start_at IS NULL OR t.start_at<=UTC_TIMESTAMP(3)) AND (t.end_at IS NULL OR t.end_at>UTC_TIMESTAMP(3))
		AND (t.daily_limit=0 OR (SELECT COUNT(*) FROM hg_trade_order od WHERE od.tenant_id=t.tenant_id AND od.task_id=t.id
			AND od.order_type=2 AND od.created_at>=UTC_DATE() AND od.created_at<UTC_DATE()+INTERVAL 1 DAY)<t.daily_limit)
		AND (t.per_member_limit=0 OR (SELECT COUNT(*) FROM hg_trade_order om WHERE om.tenant_id=t.tenant_id
			AND om.task_id=t.id AND om.member_id=? AND om.order_type=2 AND om.created_at>=UTC_DATE() AND om.created_at<UTC_DATE()+INTERVAL 1 DAY)<t.per_member_limit)
		ORDER BY t.sort,t.id LIMIT 1 FOR UPDATE`, member.LevelID, input.TenantID, input.HallID, input.MemberID)
	if errors.Is(err, sql.ErrNoRows) {
		return nil, ErrNoTaskAvailable
	}
	if err != nil {
		return nil, err
	}
	rules, err := json.Marshal(map[string]any{
		"commission_amount": task.CommissionAmount,
		"commission_rate":   task.CommissionRate,
		"deadline_at":       input.DeadlineAt.UTC().Format(time.RFC3339),
		"member_level_id":   member.LevelID,
	})
	if err != nil {
		return nil, err
	}
	result, err := tx.ExecContext(ctx, `INSERT INTO hg_trade_order
		(tenant_id,order_no,member_id,task_id,product_id,product_name,order_type,quantity,
		 unit_price_amount,total_amount,commission_amount,currency,member_level_id,rule_snapshot,
		 message,order_status,freeze_status,matched_at,created_by,updated_by)
		VALUES(?,?,?,?,0,?,2,1,0,0,?,'CNY',?,?,?,2,1,UTC_TIMESTAMP(3),0,0)`,
		input.TenantID, input.OrderNo, input.MemberID, task.ID, task.Title, task.CommissionAmount,
		member.LevelID, rules, "任务匹配成功，请在截止时间前完成")
	if err != nil {
		if isDuplicate(err) {
			return nil, ErrPendingOrderExists
		}
		return nil, err
	}
	orderID, err := result.LastInsertId()
	if err != nil {
		return nil, err
	}
	if err := tx.Commit(); err != nil {
		return nil, err
	}
	return &TaskOrder{ID: orderID, OrderNo: input.OrderNo, TaskID: task.ID, ProductName: task.Title,
		CoverURL: task.CoverURL, Quantity: 1, CommissionAmount: task.CommissionAmount, Currency: "CNY",
		MemberLevelID: member.LevelID, RuleSnapshot: rules, Message: "任务匹配成功，请在截止时间前完成",
		OrderStatus: orderStatusPending, FreezeStatus: 1, DeadlineAt: input.DeadlineAt.UTC().Format(time.RFC3339),
		MatchedAt: time.Now().UTC().Format(time.RFC3339), CreatedAt: time.Now().UTC().Format(time.RFC3339)}, nil
}

func (s *Store) TaskOrders(ctx context.Context, tenantID, memberID int64, status, offset, limit int) (*TaskOrderPage, error) {
	where := ` WHERE o.tenant_id=? AND o.member_id=? AND o.order_type=2`
	args := []any{tenantID, memberID}
	if status > 0 {
		where += ` AND o.order_status=?`
		args = append(args, status)
	}
	var total int64
	if err := s.db.GetContext(ctx, &total, `SELECT COUNT(*) FROM hg_trade_order o`+where, args...); err != nil {
		return nil, err
	}
	args = append(args, limit, offset)
	rows := make([]TaskOrder, 0)
	err := s.db.SelectContext(ctx, &rows, orderSelectSQL()+where+` ORDER BY o.created_at DESC,o.id DESC LIMIT ? OFFSET ?`, args...)
	return &TaskOrderPage{Items: rows, Total: total}, err
}

func (s *Store) TaskOrder(ctx context.Context, tenantID, memberID, orderID int64) (*TaskOrder, error) {
	var row TaskOrder
	err := s.db.GetContext(ctx, &row, orderSelectSQL()+` WHERE o.tenant_id=? AND o.member_id=? AND o.order_type=2 AND o.id=? LIMIT 1`, tenantID, memberID, orderID)
	if errors.Is(err, sql.ErrNoRows) {
		return nil, ErrOrderNotFound
	}
	return &row, err
}

func orderSelectSQL() string {
	return `SELECT o.id,o.order_no,o.task_id,o.product_id,COALESCE(NULLIF(o.product_name,''),t.title,'') AS product_name,
		COALESCE(NULLIF(p.cover_url,''),t.cover_url,'') AS cover_url,o.quantity,o.unit_price_amount,
		o.total_amount,o.commission_amount,o.currency,o.member_level_id,
		COALESCE(o.rule_snapshot,JSON_OBJECT()) AS rule_snapshot,o.message,o.order_status,o.freeze_status,
		COALESCE(JSON_UNQUOTE(JSON_EXTRACT(o.rule_snapshot,'$.deadline_at')),'') AS deadline_at,
		COALESCE(DATE_FORMAT(o.matched_at,'%Y-%m-%dT%H:%i:%sZ'),'') AS matched_at,
		COALESCE(DATE_FORMAT(o.completed_at,'%Y-%m-%dT%H:%i:%sZ'),'') AS completed_at,
		DATE_FORMAT(o.created_at,'%Y-%m-%dT%H:%i:%sZ') AS created_at,
		DATE_FORMAT(o.updated_at,'%Y-%m-%dT%H:%i:%sZ') AS updated_at,
		COALESCE(t.title,'') AS task_title,COALESCE(t.description,'') AS task_description,
		COALESCE(t.detail_html,'') AS task_detail_html,COALESCE(s.submission_no,'') AS submission_no,
		COALESCE(s.submission_status,0) AS submission_status,COALESCE(s.evidence_text,'') AS evidence_text,
		COALESCE(s.evidence_attachment_ids,JSON_ARRAY()) AS evidence_attachment_ids,
		COALESCE(s.review_reason_code,'') AS review_reason_code,COALESCE(s.review_reason,'') AS review_reason,
		COALESCE(s.allow_resubmit,2) AS allow_resubmit,
		COALESCE(DATE_FORMAT(s.created_at,'%Y-%m-%dT%H:%i:%sZ'),'') AS submitted_at,
		COALESCE(DATE_FORMAT(s.reviewed_at,'%Y-%m-%dT%H:%i:%sZ'),'') AS reviewed_at,
		COALESCE(DATE_FORMAT(s.settled_at,'%Y-%m-%dT%H:%i:%sZ'),'') AS settled_at
		FROM hg_trade_order o LEFT JOIN hg_task t ON t.tenant_id=o.tenant_id AND t.id=o.task_id
		LEFT JOIN hg_product p ON p.tenant_id=o.tenant_id AND p.id=o.product_id
		LEFT JOIN hg_task_submission s ON s.tenant_id=o.tenant_id AND s.trade_order_id=o.id`
}

func (s *Store) TaskStats(ctx context.Context, tenantID, memberID int64) (*TaskStats, error) {
	var row TaskStats
	err := s.db.GetContext(ctx, &row, `SELECT
		COALESCE(w.available_amount,0) AS available_amount,COALESCE(w.frozen_amount,0) AS frozen_amount,
		(SELECT COALESCE(SUM(ts.commission_amount),0) FROM hg_task_submission ts WHERE ts.tenant_id=? AND ts.member_id=?
			AND ts.submission_status=4 AND ts.settled_at>=UTC_DATE() AND ts.settled_at<UTC_DATE()+INTERVAL 1 DAY) AS today_commission_amount,
		(SELECT COALESCE(SUM(ys.commission_amount),0) FROM hg_task_submission ys WHERE ys.tenant_id=? AND ys.member_id=?
			AND ys.submission_status=4 AND ys.settled_at>=UTC_DATE()-INTERVAL 1 DAY AND ys.settled_at<UTC_DATE()) AS yesterday_commission_amount,
		(SELECT COUNT(*) FROM hg_trade_order tc WHERE tc.tenant_id=? AND tc.member_id=?
			AND tc.order_type=2 AND tc.created_at>=UTC_DATE() AND tc.created_at<UTC_DATE()+INTERVAL 1 DAY) AS today_claim_count,
		(SELECT COUNT(*) FROM hg_trade_order cc WHERE cc.tenant_id=? AND cc.member_id=? AND cc.order_type=2 AND cc.order_status=4
			AND cc.completed_at>=UTC_DATE() AND cc.completed_at<UTC_DATE()+INTERVAL 1 DAY) AS today_completed_count
		FROM hg_app_member m LEFT JOIN hg_wallet_account w ON w.tenant_id=m.tenant_id AND w.member_id=m.id AND w.currency='CNY'
		WHERE m.tenant_id=? AND m.id=? AND m.member_status=1 AND m.deleted_at IS NULL LIMIT 1`,
		tenantID, memberID, tenantID, memberID, tenantID, memberID, tenantID, memberID, tenantID, memberID)
	if errors.Is(err, sql.ErrNoRows) {
		return nil, ErrAccountNotFound
	}
	return &row, err
}

func (s *Store) SubmitTask(ctx context.Context, input TaskSubmissionInput) (*TaskSubmissionResult, error) {
	tx, err := s.db.BeginTxx(ctx, nil)
	if err != nil {
		return nil, err
	}
	defer tx.Rollback()
	var order struct {
		TaskID           int64  `db:"task_id"`
		MemberLevelID    int64  `db:"member_level_id"`
		CommissionAmount int64  `db:"commission_amount"`
		OrderStatus      int    `db:"order_status"`
		DeadlineAt       string `db:"deadline_at"`
	}
	err = tx.GetContext(ctx, &order, `SELECT task_id,member_level_id,commission_amount,order_status,
		COALESCE(JSON_UNQUOTE(JSON_EXTRACT(rule_snapshot,'$.deadline_at')),'') AS deadline_at
		FROM hg_trade_order WHERE tenant_id=? AND member_id=? AND order_type=2 AND id=? LIMIT 1 FOR UPDATE`,
		input.TenantID, input.MemberID, input.OrderID)
	if errors.Is(err, sql.ErrNoRows) {
		return nil, ErrOrderNotFound
	}
	if err != nil {
		return nil, err
	}
	if order.OrderStatus != orderStatusPending {
		return nil, ErrOrderState
	}
	if order.DeadlineAt != "" {
		if deadline, parseErr := time.Parse(time.RFC3339, order.DeadlineAt); parseErr != nil || !time.Now().UTC().Before(deadline) {
			if _, updateErr := tx.ExecContext(ctx, `UPDATE hg_trade_order SET order_status=5,message='任务已超时',updated_at=UTC_TIMESTAMP(3)
				WHERE tenant_id=? AND id=? AND order_status=2`, input.TenantID, input.OrderID); updateErr != nil {
				return nil, updateErr
			}
			if commitErr := tx.Commit(); commitErr != nil {
				return nil, commitErr
			}
			return nil, ErrOrderExpired
		}
	}
	if err := validateEvidenceAttachments(ctx, tx, input.TenantID, input.MemberID, input.AttachmentIDs); err != nil {
		return nil, err
	}
	attachments, err := json.Marshal(input.AttachmentIDs)
	if err != nil {
		return nil, err
	}
	now := time.Now().UTC()
	_, err = tx.ExecContext(ctx, `INSERT INTO hg_task_submission
		(tenant_id,submission_no,trade_order_id,task_id,member_id,member_level_id,evidence_text,
		 evidence_attachment_ids,submission_status,commission_amount,success_rate,allow_resubmit,created_by,updated_by)
		VALUES(?,?,?,?,?,?,?,?,1,?,0,2,0,0)`, input.TenantID, input.SubmissionNo, input.OrderID,
		order.TaskID, input.MemberID, order.MemberLevelID, input.EvidenceText, attachments, order.CommissionAmount)
	if err != nil {
		if isDuplicate(err) {
			return nil, ErrOrderState
		}
		return nil, err
	}
	result, err := tx.ExecContext(ctx, `UPDATE hg_trade_order SET order_status=3,message='已提交，等待审核',updated_at=UTC_TIMESTAMP(3)
		WHERE tenant_id=? AND id=? AND member_id=? AND order_status=2`, input.TenantID, input.OrderID, input.MemberID)
	if err != nil {
		return nil, err
	}
	if affected, _ := result.RowsAffected(); affected != 1 {
		return nil, ErrOrderState
	}
	if err := tx.Commit(); err != nil {
		return nil, err
	}
	return &TaskSubmissionResult{SubmissionNo: input.SubmissionNo, OrderStatus: orderStatusProcessing, SubmittedAt: now}, nil
}

func validateEvidenceAttachments(ctx context.Context, tx *sqlx.Tx, tenantID, memberID int64, ids []int64) error {
	if len(ids) == 0 {
		return nil
	}
	query, args, err := sqlx.In(`SELECT COUNT(*) FROM hg_sys_attachment WHERE id IN (?)
		AND tenant_id=? AND app_id='workbench' AND member_id=? AND status=1
		AND (mime_type LIKE 'image/%' OR mime_type='application/pdf')`, ids, tenantID, memberID)
	if err != nil {
		return err
	}
	var count int
	if err := tx.GetContext(ctx, &count, query, args...); err != nil {
		return err
	}
	if count != len(ids) {
		return ErrEvidenceInvalid
	}
	return nil
}

func (s *Store) OrderLedgers(ctx context.Context, tenantID, memberID int64, businessNumbers []string) ([]map[string]any, error) {
	if len(businessNumbers) == 0 {
		return []map[string]any{}, nil
	}
	query, args, err := sqlx.In(`SELECT id,ledger_no,biz_type,biz_no,entry_type,direction,amount,before_amount,after_amount,currency,remark,
		DATE_FORMAT(occurred_at,'%Y-%m-%dT%H:%i:%sZ') AS occurred_at FROM hg_wallet_ledger
		WHERE tenant_id=? AND member_id=? AND biz_no IN (?) ORDER BY occurred_at,id`, tenantID, memberID, businessNumbers)
	if err != nil {
		return nil, err
	}
	rows, err := s.db.QueryxContext(ctx, query, args...)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := make([]map[string]any, 0)
	for rows.Next() {
		item := map[string]any{}
		if err := rows.MapScan(item); err != nil {
			return nil, err
		}
		for key, value := range item {
			if bytes, ok := value.([]byte); ok {
				item[key] = string(bytes)
			}
		}
		items = append(items, item)
	}
	return items, rows.Err()
}