package bot

import (
	"context"
	"fmt"
	"math/rand"
	"regexp"
	"strconv"
	"strings"
	"time"

	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"

	"github.com/z/tg-apicreator-bot/internal/database"
	"github.com/z/tg-apicreator-bot/internal/i18n"
	"github.com/z/tg-apicreator-bot/internal/mytelegram"
)

// additional FSM states beyond the key-creation flow
const (
	stateAwaitBroadcast state = 100
)

// handleCommand routes slash commands.
func (b *Bot) handleCommand(update tgbotapi.Update) {
	msg := update.Message
	chatID := msg.Chat.ID
	cmd := msg.Command()
	args := msg.CommandArguments()

	allow, deny, lang := b.guard(update)
	if !allow {
		b.reply(chatID, deny)
		return
	}
	bundle := i18n.Get(lang)

	switch cmd {
	case "start":
		name := msg.From.FirstName
		if name == "" {
			name = msg.From.UserName
		}
		out := tgbotapi.NewMessage(chatID, fmt.Sprintf(bundle.Welcome, name))
		out.ParseMode = "HTML"
		out.ReplyMarkup = mainMenu()
		b.send(out)

	case "help":
		b.reply(chatID, bundle.Help)

	case "newkey":
		b.startCreateFlow(update, lang)

	case "mykeys":
		b.showMyKeys(update, lang)

	case "lang":
		out := tgbotapi.NewMessage(chatID, bundle.ChooseLang)
		out.ReplyMarkup = langMenu()
		b.send(out)

	case "settings":
		b.showSettings(update, lang)

	case "cancel":
		b.resetSession(msg.From.ID)
		b.reply(chatID, bundle.Cancelled)

	case "admin":
		if !b.cfg.IsAdmin(msg.From.ID) {
			b.reply(chatID, bundle.NotAuthorized)
			return
		}
		b.showAdminPanel(update, lang)

	case "stats":
		if !b.cfg.IsAdmin(msg.From.ID) {
			b.reply(chatID, bundle.NotAuthorized)
			return
		}
		b.showStats(update, lang)

	case "ban":
		b.handleBan(update, args, lang, true)

	case "unban":
		b.handleBan(update, args, lang, false)

	case "broadcast":
		if !b.cfg.IsAdmin(msg.From.ID) {
			b.reply(chatID, bundle.NotAuthorized)
			return
		}
		b.setState(msg.From.ID, stateAwaitBroadcast)
		b.reply(chatID, bundle.BroadcastPrompt)

	default:
		b.reply(chatID, bundle.UnknownCommand)
	}
}

// handleSessionText processes plain-text messages that belong to an active
// session (phone entry, OTP entry, broadcast draft).
func (b *Bot) handleSessionText(update tgbotapi.Update) {
	msg := update.Message
	uid := msg.From.ID
	chatID := msg.Chat.ID

	allow, deny, lang := b.guard(update)
	if !allow {
		b.reply(chatID, deny)
		return
	}
	bundle := i18n.Get(lang)

	s := b.session(uid)
	b.mu.RLock()
	st := s.state
	b.mu.RUnlock()

	switch st {
	case stateAwaitPhone:
		b.handlePhoneInput(update, lang, bundle)

	case stateAwaitOTP:
		b.handleOTPInput(update, lang, bundle)

	case stateAwaitBroadcast:
		if b.cfg.IsAdmin(uid) {
			b.doBroadcast(update, lang, bundle)
		} else {
			b.resetSession(uid)
		}
	}
}

// ---- key creation flow ----

func (b *Bot) startCreateFlow(update tgbotapi.Update, lang i18n.Lang) {
	uid := update.Message.From.ID
	chatID := update.Message.Chat.ID
	bundle := i18n.Get(lang)

	// Cooldown check (short window between attempts).
	if ok, retry := b.limiter.Check(uid); !ok {
		b.reply(chatID, fmt.Sprintf(bundle.Cooldown, retry))
		return
	}

	// Daily quota check.
	day := time.Now().UTC().Format("2006-01-02")
	u, err := b.repo.GetUserByTgID(uid)
	if err != nil {
		b.reply(chatID, bundle.NotAuthorized)
		return
	}
	used, err := b.repo.DailyCount(u.ID, day)
	if err != nil {
		b.logger.WarnfU("bot", uid, "daily count: %v", err)
	}
	if used >= b.cfg.Limits.Daily {
		b.reply(chatID, fmt.Sprintf(bundle.LimitReached, b.cfg.Limits.Daily))
		return
	}

	b.setState(uid, stateAwaitPhone)
	b.limiter.Touch(uid)
	out := tgbotapi.NewMessage(chatID, bundle.StartCreate)
	out.ParseMode = "HTML"
	out.ReplyMarkup = cancelKeyboard()
	b.send(out)
}

func (b *Bot) handlePhoneInput(update tgbotapi.Update, lang i18n.Lang, bundle i18n.Bundle) {
	uid := update.Message.From.ID
	chatID := update.Message.Chat.ID
	raw := strings.TrimSpace(update.Message.Text)

	phone := normalizePhone(raw)
	if !phoneRe.MatchString(phone) {
		out := tgbotapi.NewMessage(chatID, bundle.PhoneInvalid)
		out.ParseMode = "HTML"
		out.ReplyMarkup = cancelKeyboard()
		b.send(out)
		return
	}

	// Pick a proxy from rotation for this whole flow.
	pr, prID := b.proxies.NextWithID()
	opts := mytelegram.Options{Timeout: time.Duration(b.cfg.Proxy.TimeoutSeconds) * time.Second, Proxy: pr}
	client := mytelegram.New(opts)

	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(b.cfg.Proxy.TimeoutSeconds+10)*time.Second)
	defer cancel()

	hash, err := client.SendPassword(ctx, phone)
	if err != nil {
		b.proxies.MarkUsed(prID, true)
		b.logger.WarnfU("bot", uid, "send_password for %s: %v", maskPhone(phone), err)
		b.reply(chatID, fmt.Sprintf(bundle.Failed, escapeHTML(err.Error())))
		b.resetSession(uid)
		return
	}
	b.proxies.MarkUsed(prID, false)

	s := b.session(uid)
	b.mu.Lock()
	s.phone = phone
	s.randomHash = hash
	s.proxy = pr
	s.proxyID = prID
	s.state = stateAwaitOTP
	b.mu.Unlock()

	out := tgbotapi.NewMessage(chatID, bundle.WaitingOTP)
	out.ParseMode = "HTML"
	out.ReplyMarkup = cancelKeyboard()
	b.send(out)
}

func (b *Bot) handleOTPInput(update tgbotapi.Update, lang i18n.Lang, bundle i18n.Bundle) {
	uid := update.Message.From.ID
	chatID := update.Message.Chat.ID

	s := b.session(uid)
	b.mu.RLock()
	phone := s.phone
	rhash := s.randomHash
	pr := s.proxy
	prID := s.proxyID
	b.mu.RUnlock()

	if phone == "" || rhash == "" {
		b.resetSession(uid)
		b.reply(chatID, bundle.StartCreate)
		return
	}

	otp := strings.TrimSpace(update.Message.Text)
	otp = digitsOnly(otp)

	// Acknowledge immediately so the user knows work has started.
	b.reply(chatID, bundle.CreatingApp)

	// Reset the FSM so the user can start another flow; the heavy work runs in
	// a goroutine and replies when done.
	b.resetSession(uid)

	go b.finalizeCreation(uid, chatID, phone, rhash, otp, pr, prID, lang, bundle)
}

// finalizeCreation performs the login + app creation and reports the result.
// It runs in its own goroutine so the bot stays responsive for other users.
func (b *Bot) finalizeCreation(uid, chatID int64, phone, rhash, otp string, pr mytelegram.Proxy, prID int64, lang i18n.Lang, bundle i18n.Bundle) {
	defer func() {
		if r := recover(); r != nil {
			b.logger.ErrorfU("bot", uid, "finalizeCreation panic: %v", r)
			b.reply(chatID, fmt.Sprintf(bundle.Failed, escapeHTML(fmt.Sprintf("internal error: %v", r))))
		}
	}()

	opts := mytelegram.Options{Timeout: time.Duration(b.cfg.Proxy.TimeoutSeconds) * time.Second, Proxy: pr}
	client := mytelegram.New(opts)

	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
	defer cancel()

	if err := client.Login(ctx, phone, rhash, otp); err != nil {
		b.proxies.MarkUsed(prID, true)
		b.logger.WarnfU("bot", uid, "login for %s: %v", maskPhone(phone), err)
		b.reply(chatID, fmt.Sprintf(bundle.Failed, escapeHTML(err.Error())))
		return
	}

	fields := randomAppFields()
	apiID, apiHash, err := client.CreateApp(ctx, fields)
	if err != nil {
		b.proxies.MarkUsed(prID, true)
		b.logger.WarnfU("bot", uid, "create_app for %s: %v", maskPhone(phone), err)
		b.reply(chatID, fmt.Sprintf(bundle.Failed, escapeHTML(err.Error())))
		return
	}
	b.proxies.MarkUsed(prID, false)

	// Persist the key.
	u, err := b.repo.GetUserByTgID(uid)
	if err != nil {
		b.logger.ErrorfU("bot", uid, "fetch user after create: %v", err)
	} else {
		_, _ = b.repo.CreateAPIKey(database.APIKey{
			UserID:       u.ID,
			TgID:         u.TgID,
			Phone:        phone,
			AppTitle:     fields.Title,
			AppShortname: fields.ShortName,
			AppPlatform:  fields.Platform,
			APIID:        apiID,
			APIHash:      apiHash,
			Status:       "active",
		})
		_ = b.repo.IncrementCreatedCount(u.ID)
		// Bump daily counter.
		day := time.Now().UTC().Format("2006-01-02")
		_, _ = b.repo.IncrementDaily(u.ID, day)
	}

	b.logger.InfofU("bot", uid, "created api_id=%s api_hash=%s for phone %s", apiID, maskHash(apiHash), maskPhone(phone))

	b.reply(chatID, fmt.Sprintf(bundle.Success, escapeHTML(fields.Title), apiID, apiHash))
}

// ---- listing / settings ----

func (b *Bot) showMyKeys(update tgbotapi.Update, lang i18n.Lang) {
	uid := update.Message.From.ID
	chatID := update.Message.Chat.ID
	bundle := i18n.Get(lang)

	u, err := b.repo.GetUserByTgID(uid)
	if err != nil {
		b.reply(chatID, bundle.NotAuthorized)
		return
	}
	keys, err := b.repo.ListAPIKeysByUser(u.ID)
	if err != nil {
		b.reply(chatID, bundle.Failed)
		return
	}
	if len(keys) == 0 {
		b.reply(chatID, bundle.NoKeys)
		return
	}

	var sb strings.Builder
	for _, k := range keys {
		status := bundle.Active
		if k.Status != "active" {
			status = bundle.Revoked
		}
		fmt.Fprintf(&sb, "• <b>%s</b>\n  api_id: <code>%s</code>\n  api_hash: <code>%s</code>\n  %s • %s\n\n",
			escapeHTML(k.AppTitle), k.APIID, maskHash(k.APIHash), status, k.CreatedAt)
	}
	b.reply(chatID, fmt.Sprintf(bundle.MyKeys, len(keys), sb.String()))
}

func (b *Bot) showSettings(update tgbotapi.Update, lang i18n.Lang) {
	uid := update.Message.From.ID
	chatID := update.Message.Chat.ID
	bundle := i18n.Get(lang)
	u, err := b.repo.GetUserByTgID(uid)
	if err != nil {
		b.reply(chatID, bundle.NotAuthorized)
		return
	}
	b.reply(chatID, fmt.Sprintf(bundle.Settings, i18n.LangLabel(i18n.Normalize(u.Language)), b.cfg.Limits.Daily, b.proxies.Count()))
}

// ---- admin ----

func (b *Bot) showAdminPanel(update tgbotapi.Update, lang i18n.Lang) {
	chatID := update.Message.Chat.ID
	bundle := i18n.Get(lang)
	st, err := b.repo.Stats()
	if err != nil {
		b.reply(chatID, bundle.Failed)
		return
	}
	webLink := b.cfg.Web.BaseURL
	out := tgbotapi.NewMessage(chatID, fmt.Sprintf("%s\n\n🌐 %s", fmt.Sprintf(bundle.AdminPanel, st.Users, st.Keys, st.KeysToday, st.ActiveProx), webLink))
	out.ReplyMarkup = adminMenu()
	b.send(out)
}

func (b *Bot) showStats(update tgbotapi.Update, lang i18n.Lang) {
	chatID := update.Message.Chat.ID
	bundle := i18n.Get(lang)
	st, err := b.repo.Stats()
	if err != nil {
		b.reply(chatID, bundle.Failed)
		return
	}
	b.reply(chatID, fmt.Sprintf(bundle.Stats, st.Users, st.Keys, st.KeysToday, st.Proxies, st.ActiveProx, st.Banned))
}

func (b *Bot) handleBan(update tgbotapi.Update, args string, lang i18n.Lang, ban bool) {
	chatID := update.Message.Chat.ID
	bundle := i18n.Get(lang)
	uid := update.Message.From.ID

	if !b.cfg.IsAdmin(uid) {
		b.reply(chatID, bundle.NotAuthorized)
		return
	}
	arg := strings.TrimSpace(args)
	if arg == "" {
		if ban {
			b.reply(chatID, bundle.BanUsage)
		} else {
			b.reply(chatID, bundle.UnbanUsage)
		}
		return
	}
	target, err := strconv.ParseInt(arg, 10, 64)
	if err != nil {
		b.reply(chatID, bundle.UserNotFound)
		return
	}
	if err := b.repo.SetBanned(target, ban); err != nil {
		b.reply(chatID, bundle.UserNotFound)
		return
	}
	if ban {
		b.reply(chatID, fmt.Sprintf(bundle.BannedUser, target))
		b.logger.InfofU("bot", uid, "banned user %d", target)
	} else {
		b.reply(chatID, fmt.Sprintf(bundle.UnbannedUser, target))
		b.logger.InfofU("bot", uid, "unbanned user %d", target)
	}
}

func (b *Bot) doBroadcast(update tgbotapi.Update, lang i18n.Lang, bundle i18n.Bundle) {
	uid := update.Message.From.ID
	chatID := update.Message.Chat.ID
	text := strings.TrimSpace(update.Message.Text)
	b.resetSession(uid)

	if text == "" {
		b.reply(chatID, bundle.BroadcastFailed)
		return
	}

	users, _, err := b.repo.ListUsers(100000, 0)
	if err != nil {
		b.reply(chatID, fmt.Sprintf(bundle.BroadcastFailed, escapeHTML(err.Error())))
		return
	}

	ok, fail := 0, 0
	for _, u := range users {
		if u.IsBanned {
			continue
		}
		m := tgbotapi.NewMessage(u.TgID, text)
		m.ParseMode = "HTML"
		m.DisableWebPagePreview = true
		if _, err := b.api.Send(m); err != nil {
			fail++
		} else {
			ok++
		}
		// Telegram rate limit: ~30 msg/s globally. Sleep a little.
		time.Sleep(40 * time.Millisecond)
	}
	b.reply(chatID, fmt.Sprintf(bundle.BroadcastSent, ok, fail))
	b.logger.InfofU("bot", uid, "broadcast sent ok=%d fail=%d", ok, fail)
}

// ---- callbacks ----

func (b *Bot) handleCallback(update tgbotapi.Update) {
	cq := update.CallbackQuery
	uid := cq.From.ID
	data := cq.Data
	b.answerCallback(cq.ID, "")

	allow, deny, lang := b.guard(update)
	if !allow {
		b.reply(chatIDOf(update), deny)
		return
	}
	bundle := i18n.Get(lang)

	// Callbacks may arrive on a message we can edit; resolve it safely.
	var msgID int
	var chatID int64
	if cq.Message != nil {
		msgID = cq.Message.MessageID
		chatID = cq.Message.Chat.ID
	}

	switch {
	case data == "lang_menu":
		b.editOrSend(chatID, msgID, bundle.ChooseLang, langMenu())

	case data == cbLangFA:
		b.setLang(uid, i18n.Fa, chatID, msgID)
	case data == cbLangEN:
		b.setLang(uid, i18n.En, chatID, msgID)

	case data == cbNewKey:
		// Trigger the flow as if /newkey were typed.
		fake := update
		if fake.Message == nil {
			fake.Message = &tgbotapi.Message{}
		}
		fake.Message.Chat = cq.Message.Chat
		fake.Message.From = cq.From
		b.startCreateFlow(fake, lang)

	case data == cbMyKeys:
		b.showMyKeysCallback(uid, chatID, msgID, lang)

	case data == cbCancel:
		b.resetSession(uid)
		b.editOrSend(chatID, msgID, bundle.Cancelled, mainMenu())

	case data == cbAdminStats:
		if !b.cfg.IsAdmin(uid) {
			return
		}
		b.showStatsCallback(chatID, msgID, lang)

	case data == cbAdminUsers:
		if !b.cfg.IsAdmin(uid) {
			return
		}
		b.reply(chatID, bundle.AdminPanel) // placeholder; full list is in web panel

	case strings.HasPrefix(data, cbRevokePrefix):
		idStr := strings.TrimPrefix(data, cbRevokePrefix)
		id, err := strconv.ParseInt(idStr, 10, 64)
		if err != nil {
			return
		}
		if err := b.repo.RevokeAPIKey(id); err != nil {
			b.reply(chatID, bundle.UserNotFound)
			return
		}
		b.reply(chatID, bundle.RevokedKey)
	}
}

func (b *Bot) setLang(uid int64, lang i18n.Lang, chatID int64, msgID int) {
	u, err := b.repo.GetUserByTgID(uid)
	if err == nil {
		_ = b.repo.SetLanguage(u.ID, string(lang))
	}
	bundle := i18n.Get(lang)
	b.editOrSend(chatID, msgID, fmt.Sprintf(bundle.LangSet, i18n.LangLabel(lang)), mainMenu())
}

func (b *Bot) showMyKeysCallback(uid int64, chatID int64, msgID int, lang i18n.Lang) {
	u, err := b.repo.GetUserByTgID(uid)
	if err != nil {
		b.reply(chatID, i18n.Get(lang).NotAuthorized)
		return
	}
	keys, err := b.repo.ListAPIKeysByUser(u.ID)
	bundle := i18n.Get(lang)
	if err != nil || len(keys) == 0 {
		b.editOrSend(chatID, msgID, bundle.NoKeys, mainMenu())
		return
	}
	var sb strings.Builder
	for _, k := range keys {
		status := bundle.Active
		if k.Status != "active" {
			status = bundle.Revoked
		}
		fmt.Fprintf(&sb, "• <b>%s</b>\n  api_id: <code>%s</code>\n  api_hash: <code>%s</code>\n  %s • %s\n\n",
			escapeHTML(k.AppTitle), k.APIID, maskHash(k.APIHash), status, k.CreatedAt)
	}
	b.editOrSend(chatID, msgID, fmt.Sprintf(bundle.MyKeys, len(keys), sb.String()), mainMenu())
}

func (b *Bot) showStatsCallback(chatID int64, msgID int, lang i18n.Lang) {
	st, err := b.repo.Stats()
	bundle := i18n.Get(lang)
	if err != nil {
		b.editOrSend(chatID, msgID, bundle.Failed, adminMenu())
		return
	}
	b.editOrSend(chatID, msgID, fmt.Sprintf(bundle.Stats, st.Users, st.Keys, st.KeysToday, st.Proxies, st.ActiveProx, st.Banned), adminMenu())
}

// ---- send helpers ----

func (b *Bot) send(c tgbotapi.Chattable) {
	if _, err := b.api.Send(c); err != nil {
		b.logf("warn", "send failed: %v", err)
	}
}

// editOrSend tries to edit the existing inline-message; if that fails (e.g.
// the message had no markup, or content is identical) it falls back to a new
// message.
func (b *Bot) editOrSend(chatID int64, msgID int, text string, markup tgbotapi.InlineKeyboardMarkup) {
	if chatID == 0 || msgID == 0 {
		m := tgbotapi.NewMessage(chatID, text)
		m.ParseMode = "HTML"
		m.ReplyMarkup = markup
		b.send(m)
		return
	}
	edit := tgbotapi.NewEditMessageTextAndMarkup(chatID, msgID, text, markup)
	edit.ParseMode = "HTML"
	if _, err := b.api.Send(edit); err != nil {
		m := tgbotapi.NewMessage(chatID, text)
		m.ParseMode = "HTML"
		m.ReplyMarkup = markup
		b.send(m)
	}
}

// ---- text / value helpers ----

var phoneRe = regexp.MustCompile(`^\d{7,15}$`)

func normalizePhone(s string) string {
	s = strings.TrimSpace(s)
	s = strings.TrimPrefix(s, "+")
	s = strings.ReplaceAll(s, " ", "")
	s = strings.ReplaceAll(s, "-", "")
	return s
}

func digitsOnly(s string) string {
	var sb strings.Builder
	for _, r := range s {
		if r >= '0' && r <= '9' {
			sb.WriteRune(r)
		}
	}
	return sb.String()
}

const (
	letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
	lower   = "abcdefghijklmnopqrstuvwxyz"
)

func randomAppFields() mytelegram.AppFields {
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	return mytelegram.AppFields{
		Title:     randString(r, letters, 8),
		ShortName: randString(r, lower, 6),
		URL:       randString(r, lower, 5) + ".com",
		Platform:  "android",
		Desc:      "",
	}
}

func randString(r *rand.Rand, set string, n int) string {
	b := make([]byte, n)
	for i := range b {
		b[i] = set[r.Intn(len(set))]
	}
	return string(b)
}

// maskPhone hides the middle of a phone number for logs.
func maskPhone(s string) string {
	if len(s) <= 4 {
		return strings.Repeat("*", len(s))
	}
	return s[:3] + strings.Repeat("*", len(s)-6) + s[len(s)-3:]
}

// maskHash shows only the first/last few chars of an api_hash.
func maskHash(s string) string {
	if len(s) <= 8 {
		return s
	}
	return s[:6] + "…" + s[len(s)-4:]
}

// escapeHTML escapes the few characters that matter for Telegram HTML.
func escapeHTML(s string) string {
	s = strings.ReplaceAll(s, "&", "&amp;")
	s = strings.ReplaceAll(s, "<", "&lt;")
	s = strings.ReplaceAll(s, ">", "&gt;")
	return s
}
