package store

import (
	"context"
	"database/sql"
	"time"
)

func (db *DB) GetDailyUsage(ctx context.Context, userID int64, date time.Time) (*DailyUsage, error) {
	d := date.Format("2006-01-02")
	row := db.QueryRowContext(ctx, `
		SELECT user_id, usage_date, leads_added, exports_count
		FROM daily_usage WHERE user_id = ? AND usage_date = ?`, userID, d)
	var u DailyUsage
	err := row.Scan(&u.UserID, &u.UsageDate, &u.LeadsAdded, &u.ExportsCount)
	if err == sql.ErrNoRows {
		return &DailyUsage{UserID: userID, UsageDate: date}, nil
	}
	if err != nil {
		return nil, err
	}
	return &u, nil
}

func (db *DB) IncrementLeadsAdded(ctx context.Context, userID int64) error {
	d := time.Now().Format("2006-01-02")
	_, err := db.ExecContext(ctx, `
		INSERT INTO daily_usage (user_id, usage_date, leads_added, exports_count)
		VALUES (?, ?, 1, 0)
		ON DUPLICATE KEY UPDATE leads_added = leads_added + 1`, userID, d)
	return err
}

func (db *DB) IncrementExports(ctx context.Context, userID int64) error {
	d := time.Now().Format("2006-01-02")
	_, err := db.ExecContext(ctx, `
		INSERT INTO daily_usage (user_id, usage_date, leads_added, exports_count)
		VALUES (?, ?, 0, 1)
		ON DUPLICATE KEY UPDATE exports_count = exports_count + 1`, userID, d)
	return err
}

func (db *DB) ComputeLimits(ctx context.Context, userID int64, sub *Subscription) (*UserLimits, error) {
	if sub == nil || sub.Plan == nil {
		reason := "Nenhum plano ativo"
		return &UserLimits{CanUseApp: false, BlockReason: &reason}, nil
	}
	plan := sub.Plan
	active, err := db.CountActiveLeads(ctx, userID)
	if err != nil {
		return nil, err
	}
	usage, err := db.GetDailyUsage(ctx, userID, time.Now())
	if err != nil {
		return nil, err
	}
	slots := plan.MaxActiveLeads - active
	if slots < 0 {
		slots = 0
	}
	canUse := sub.Status == "trial" || sub.Status == "active"
	var reason *string
	if !canUse {
		r := "Plano inativo ou expirado"
		reason = &r
	}
	return &UserLimits{
		MaxActiveLeads:   plan.MaxActiveLeads,
		ActiveLeadsCount: active,
		SlotsRemaining:   slots,
		MaxAddPerDay:     plan.MaxAddPerDay,
		AddedToday:       usage.LeadsAdded,
		CanExport:        plan.CanExport,
		ExportsToday:     usage.ExportsCount,
		MaxExportPerDay:  plan.MaxExportPerDay,
		CanUseApp:        canUse,
		BlockReason:      reason,
	}, nil
}

func (db *DB) LogAudit(ctx context.Context, actorID *int64, action, targetType, targetID string, meta string) error {
	_, err := db.ExecContext(ctx, `
		INSERT INTO audit_log (actor_user_id, action, target_type, target_id, meta)
		VALUES (?, ?, ?, ?, ?)`, actorID, action, targetType, targetID, meta)
	return err
}

func (db *DB) CountLeadsAddedTodayAll(ctx context.Context) (int, error) {
	var n int
	err := db.QueryRowContext(ctx, `
		SELECT COALESCE(SUM(leads_added),0) FROM daily_usage WHERE usage_date = CURDATE()`).Scan(&n)
	return n, err
}

func (db *DB) CountActiveUsers(ctx context.Context) (int, error) {
	var n int
	err := db.QueryRowContext(ctx, `
		SELECT COUNT(DISTINCT user_id) FROM subscriptions WHERE status IN ('trial','active')`).Scan(&n)
	return n, err
}