package business

import (
	"context"
	"errors"
	"time"

	"gorm.io/gorm"
	"gorm.io/gorm/clause"
	"kra/internal/biz/business"
)

type alertTriggerRepo struct{ data Provider }

func NewAlertTriggerRepo(data Provider) business.AlertTriggerRepo {
	return &alertTriggerRepo{data: data}
}

type alertTriggerLockPO struct {
	SourceDB  string `gorm:"column:source_db;primaryKey;size:50"`
	PromoteID uint64 `gorm:"primaryKey;autoIncrement:false"`
	RuleType  string `gorm:"primaryKey;size:50"`
}

func (alertTriggerLockPO) TableName() string { return "sys_business_alert_locks" }

func (r *alertTriggerRepo) Input(ctx context.Context) (*business.AlertTriggerInput, error) {
	db := r.data.DB().WithContext(ctx)
	out := &business.AlertTriggerInput{}
	var rules []alertRulePO
	if err := db.Where("enabled=1 AND is_deleted=0").Order("id").Find(&rules).Error; err != nil {
		return nil, business.ErrStorage
	}
	for _, row := range rules {
		out.Rules = append(out.Rules, toBizAlertRule(row))
	}
	if len(rules) == 0 {
		return out, nil
	}
	var accounts []accountPO
	if err := db.Select("id,username,level,parent_id,id_path,authority_id").Find(&accounts).Error; err != nil {
		return nil, business.ErrStorage
	}
	for _, row := range accounts {
		out.Accounts = append(out.Accounts, toBizAccount(row))
	}
	var bindings []bindingPO
	if err := db.Where("status=?", "0").Find(&bindings).Error; err != nil {
		return nil, business.ErrStorage
	}
	for _, row := range bindings {
		out.Bindings = append(out.Bindings, toBizBinding(row))
	}
	if len(bindings) == 0 {
		return out, nil
	}
	available, err := businessTableAvailable(db, "tab_promote")
	if err != nil {
		return nil, err
	}
	if !available {
		return nil, business.ErrAlertChannelsUnavailable
	}
	var channels []struct {
		ID, BusierID              uint64
		SourceDB                  string `gorm:"column:source_db"`
		Account                   string
		LastLoginTime, CreateTime *int64
	}
	bound := db.Table("sys_user_bind_platform b").Select("1").Where("b.status=? AND b.source_db=p.source_db AND b.platform_busier_id=p.busier_id", "0")
	if err := db.Table("tab_promote p").Select("p.id,p.source_db,p.account,p.busier_id,p.last_login_time,p.create_time").Where("p.promote_level=1 AND p.status=1").Where("EXISTS (?)", bound).Order("p.source_db,p.id").Scan(&channels).Error; err != nil {
		return nil, business.ErrStorage
	}
	for _, row := range channels {
		channel := &business.AlertTriggerChannel{ChannelKey: business.ChannelKey{SourceDB: row.SourceDB, ID: row.ID}, Account: row.Account, BusierID: row.BusierID}
		if row.LastLoginTime != nil {
			channel.LastLoginUnix = *row.LastLoginTime
		}
		if row.CreateTime != nil {
			channel.CreatedUnix = *row.CreateTime
		}
		out.Channels = append(out.Channels, channel)
	}
	return out, nil
}

func (r *alertTriggerRepo) Comparison(ctx context.Context, metric int, channels []business.ChannelKey, today time.Time, days int) (map[business.ChannelKey]business.AlertComparison, error) {
	db := r.data.DB().WithContext(ctx)
	table, stamp, amount, condition := "tab_user", "register_time", "1", "(puid=0 OR puid IS NULL)"
	if metric == 2 {
		table, stamp, amount, condition = "tab_spend", "pay_time", "pay_amount", "pay_status=1"
	} else if metric != 1 {
		return nil, business.ErrAlertRuleInput
	}
	available, err := businessTableAvailable(db, table)
	if err != nil {
		return nil, err
	}
	if !available {
		return nil, business.ErrReportBuildUnavailable
	}
	result := map[business.ChannelKey]business.AlertComparison{}
	currentStart, previousStart := today.AddDate(0, 0, -days).Unix(), today.AddDate(0, 0, -2*days).Unix()
	for start := 0; start < len(channels); start += 500 {
		var rows []struct {
			SourceDB                    string `gorm:"column:source_db"`
			PromoteID                   uint64
			FirstUnix                   *int64
			CurrentValue, PreviousValue string
		}
		// 原始主账号与成功支付口径，不扩展下级渠道，也不使用身份证偏好。
		selection := "source_db,promote_id,MIN(" + stamp + ") AS first_unix," +
			"COALESCE(SUM(CASE WHEN " + stamp + ">=? AND " + stamp + "<? THEN " + amount + " ELSE 0 END),0) AS current_value," +
			"COALESCE(SUM(CASE WHEN " + stamp + ">=? AND " + stamp + "<? THEN " + amount + " ELSE 0 END),0) AS previous_value"
		if err := db.Table(table).Select(selection, currentStart, today.Unix(), previousStart, currentStart).Where(condition).Where("(source_db,promote_id) IN ?", channelPairs(channels[start:min(start+500, len(channels))])).Group("source_db,promote_id").Scan(&rows).Error; err != nil {
			return nil, business.ErrStorage
		}
		for _, row := range rows {
			value := business.AlertComparison{Current: row.CurrentValue, Previous: row.PreviousValue}
			if row.FirstUnix != nil {
				value.FirstUnix = *row.FirstUnix
			}
			result[business.ChannelKey{SourceDB: row.SourceDB, ID: row.PromoteID}] = value
		}
	}
	return result, nil
}

func (r *alertTriggerRepo) StoreHit(ctx context.Context, hit *business.AlertRecord, open []int, shouldWrite func(*business.AlertRecord) bool) (bool, error) {
	written := false
	err := r.data.DB().WithContext(ctx).Transaction(func(tx *gorm.DB) error {
		key := alertTriggerLockPO{SourceDB: hit.PlatformCode, PromoteID: hit.TargetPromoteID, RuleType: hit.RuleType}
		if err := tx.Clauses(clause.OnConflict{DoNothing: true}).Create(&key).Error; err != nil {
			return business.ErrStorage
		}
		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).Where("source_db=? AND promote_id=? AND rule_type=?", key.SourceDB, key.PromoteID, key.RuleType).Take(&key).Error; err != nil {
			return business.ErrStorage
		}
		var previous alertRecordPO
		err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).Where("platform_code=? AND target_promote_id=? AND rule_type=? AND status IN ?", key.SourceDB, key.PromoteID, key.RuleType, open).Order("id").Take(&previous).Error
		if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
			return business.ErrStorage
		}
		var current *business.AlertRecord
		if err == nil {
			current = toBizAlertRecord(previous)
		}
		if !shouldWrite(current) {
			return nil
		}
		day := time.Date(hit.CreatedAt.Year(), hit.CreatedAt.Month(), hit.CreatedAt.Day(), 0, 0, 0, 0, hit.CreatedAt.Location())
		row := alertRecordPO{PlatformCode: hit.PlatformCode, PlatformName: hit.PlatformName, RuleID: hit.RuleID, RuleName: hit.RuleName, RuleType: hit.RuleType,
			MonitorMetric: hit.MonitorMetric, TargetPromoteID: hit.TargetPromoteID, TargetPromoteName: hit.TargetPromoteName, BusinessID: hit.BusinessID, BusinessName: hit.BusinessName,
			AlertContent: hit.AlertContent, Status: hit.Status, AlertDate: &day, CreatedAt: hit.CreatedAt, UpdatedAt: hit.UpdatedAt}
		if current == nil {
			err = tx.Create(&row).Error
		} else {
			row.ID = previous.ID
			err = tx.Model(&alertRecordPO{}).Where("id=?", previous.ID).Select("platform_name", "rule_id", "rule_name", "rule_type", "monitor_metric", "target_promote_name", "business_id", "business_name", "alert_content", "status", "alert_date", "created_at", "updated_at").Updates(&row).Error
		}
		if err != nil {
			return business.ErrStorage
		}
		written = true
		return nil
	})
	return written, err
}