package main

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"strconv"
	"strings"
	"time"

	"github.com/jackc/pgx/v5"
	"github.com/jackc/pgx/v5/pgxpool"

	"telesrv/internal/domain"
)

const (
	accountSearchLimit      = 20
	accountListDefaultLimit = 50
	accountListMaxLimit     = 100
	channelSearchLimit      = 50
	channelListDefaultLimit = 50
	channelListMaxLimit     = 100
	messagePageLimit        = 100
)

type readStore struct {
	pool *pgxpool.Pool
}

func newReadStore(pool *pgxpool.Pool) *readStore {
	return &readStore{pool: pool}
}

type AccountRow struct {
	ID           int64
	Phone        string
	Username     string
	FirstName    string
	LastName     string
	CreatedAt    time.Time
	UpdatedAt    time.Time
	Frozen       bool
	Reason       string
	Verified     bool
	Scam         bool
	Fake         bool
	PremiumUntil int64
	LastActiveAt time.Time
	DeviceCount  int
	LoginEmail   string
}

type AccountDetail struct {
	Account        AccountRow
	About          string
	LastSeenAt     int64
	Verified       bool
	Scam           bool
	Fake           bool
	Support        bool
	Bot            bool
	StarsBalance   int64
	StarsGranted   bool
	Restriction    RestrictionRow
	HasRestriction bool
	Authorizations []AuthorizationRow
	AuditLogs      []AuditLogRow
}

type RestrictionRow struct {
	Frozen    bool
	Since     *time.Time
	Until     *time.Time
	AppealURL string
	Reason    string
	Actor     string
	CommandID string
	UpdatedAt time.Time
}

type AuthorizationRow struct {
	AuthKeyID       int64
	Hash            int64
	Layer           int
	DeviceModel     string
	Platform        string
	SystemVersion   string
	APIID           int
	AppVersion      string
	IP              string
	PasswordPending bool
	CreatedAt       time.Time
	ActiveAt        time.Time
}

type AuditLogRow struct {
	ID        int64
	CommandID string
	Actor     string
	Action    string
	DryRun    bool
	Reason    string
	Status    string
	Error     string
	Result    string
	CreatedAt time.Time
}

type ChannelRow struct {
	ID                 int64
	AccessHash         int64
	CreatorUserID      int64
	Title              string
	About              string
	Username           string
	Broadcast          bool
	Megagroup          bool
	Forum              bool
	Monoforum          bool
	Verified           bool
	Scam               bool
	Fake               bool
	Gigagroup          bool
	Deleted            bool
	AntiSpam           bool
	ParticipantsHidden bool
	NoForwards         bool
	JoinToSend         bool
	JoinRequest        bool
	SlowmodeSeconds    int
	ParticipantsCount  int
	AdminsCount        int
	KickedCount        int
	BannedCount        int
	TopMessageID       int
	PinnedMessageID    int
	PTS                int
	Date               int
	CreatedAt          time.Time
	UpdatedAt          time.Time
}

type ChannelDetail struct {
	Channel     ChannelRow
	ChannelJSON string
	AuditLogs   []AuditLogRow
}

type StarGiftRow struct {
	GiftID        int64 `json:"GiftID,string"`
	RevisionID    int64 `json:"RevisionID,string"`
	Revision      int
	Title         string
	Stars         int64 `json:"Stars,string"`
	ConvertStars  int64 `json:"ConvertStars,string"`
	Enabled       bool
	SortOrder     int
	DocumentID    int64 `json:"DocumentID,string"`
	SourceName    string
	SourceFormat  string
	AnimationSHA  string
	AnimationSize int64 `json:"AnimationSize,string"`
	Width         int
	Height        int
	FrameRate     float64
	ReceivedCount int64 `json:"ReceivedCount,string"`
	CreatedBy     string
	UpdatedAt     time.Time
}

func (s *readStore) ListStarGifts(ctx context.Context) ([]StarGiftRow, error) {
	rows, err := s.pool.Query(ctx, `
SELECT c.gift_id, r.id, r.revision, r.title, r.stars, r.convert_stars,
       c.enabled, c.sort_order, r.document_id, r.source_name, r.source_format,
       encode(r.animation_sha256, 'hex'), d.size, r.width, r.height, r.frame_rate,
       (SELECT COUNT(*) FROM peer_star_gifts p WHERE p.gift_id = c.gift_id),
       r.created_by, c.updated_at
FROM star_gift_catalog c
JOIN star_gift_catalog_revisions r ON r.id = c.active_revision_id
JOIN documents d ON d.id = r.document_id
ORDER BY c.sort_order, c.gift_id
LIMIT $1`, domain.MaxStarGiftCatalogSize)
	if err != nil {
		return nil, fmt.Errorf("list star gifts: %w", err)
	}
	defer rows.Close()
	out := make([]StarGiftRow, 0)
	for rows.Next() {
		var row StarGiftRow
		if err := rows.Scan(
			&row.GiftID, &row.RevisionID, &row.Revision, &row.Title, &row.Stars, &row.ConvertStars,
			&row.Enabled, &row.SortOrder, &row.DocumentID, &row.SourceName, &row.SourceFormat,
			&row.AnimationSHA, &row.AnimationSize, &row.Width, &row.Height, &row.FrameRate,
			&row.ReceivedCount, &row.CreatedBy, &row.UpdatedAt,
		); err != nil {
			return nil, err
		}
		out = append(out, row)
	}
	return out, rows.Err()
}

type StickerSetRow struct {
	// ID must round-trip through JSON as a string: these are Telegram-style
	// snowflake ids (18-19 digits), well past JS's 2^53 safe-integer limit, so
	// a plain JSON number gets silently rounded by the browser (see StarGiftRow
	// for the same fix applied to gift ids).
	ID        int64 `json:"ID,string"`
	ShortName string
	Title     string
	Count     int
	Kind      string
	SystemKey string
	Official  bool
	Archived  bool
	Installed bool
	SortOrder int
	CreatedAt time.Time
	// CoverDocumentID is the first document in the set, used as a small
	// thumbnail in the admin list — empty when the set has no documents yet.
	// Extracted straight from the jsonb array as text (document_ids->>0), so
	// it never round-trips through a JSON number and risks the same 2^53
	// precision loss as ID above.
	CoverDocumentID string
}

// ListStickerSets lists non-system sticker/emoji sets. kind filters to exactly
// that set_kind ("stickers", "emoji", "masks"); an empty kind lists all of
// them (still excluding "system" — dice, animated emoji, premium/TON gifts
// and similar built-in packs are never admin-editable).
func (s *readStore) ListStickerSets(ctx context.Context, kind string) ([]StickerSetRow, error) {
	rows, err := s.pool.Query(ctx, `
SELECT id, short_name, title, count, set_kind, system_key, official, archived, installed, sort_order, created_at,
       COALESCE(document_ids->>0, '')
FROM sticker_sets
WHERE deleted = false AND set_kind <> 'system'
  AND ($1 = '' OR set_kind = $1)
ORDER BY set_kind, sort_order, id`, kind)
	if err != nil {
		return nil, fmt.Errorf("list sticker sets: %w", err)
	}
	defer rows.Close()
	out := make([]StickerSetRow, 0)
	for rows.Next() {
		var item StickerSetRow
		if err := rows.Scan(&item.ID, &item.ShortName, &item.Title, &item.Count, &item.Kind, &item.SystemKey, &item.Official, &item.Archived, &item.Installed, &item.SortOrder, &item.CreatedAt, &item.CoverDocumentID); err != nil {
			return nil, err
		}
		out = append(out, item)
	}
	return out, rows.Err()
}

// StickerSetDocumentIDs returns document ids as strings, not int64 — a plain
// JSON number array would let the browser silently round these snowflake ids
// past 2^53 (see StickerSetRow.ID for the same issue on the set id itself).
func (s *readStore) StickerSetDocumentIDs(ctx context.Context, setID int64) ([]string, error) {
	// jsonb must be cast to text and scanned as a string — see the identical
	// ::text-cast pattern in internal/store/postgres/media.go's sticker set
	// select; scanning jsonb straight into []byte does not reliably decode here.
	var raw string
	err := s.pool.QueryRow(ctx, `SELECT document_ids::text FROM sticker_sets WHERE id = $1 AND deleted = false`, setID).Scan(&raw)
	if err != nil {
		if errors.Is(err, pgx.ErrNoRows) {
			return nil, nil
		}
		return nil, fmt.Errorf("sticker set documents: %w", err)
	}
	var ids []int64
	if raw != "" && raw != "[]" {
		if err := json.Unmarshal([]byte(raw), &ids); err != nil {
			return nil, fmt.Errorf("sticker set documents: %w", err)
		}
	}
	out := make([]string, len(ids))
	for i, id := range ids {
		out[i] = strconv.FormatInt(id, 10)
	}
	return out, nil
}

func (s *readStore) SearchAccounts(ctx context.Context, q string) ([]AccountRow, error) {
	q = strings.TrimSpace(q)
	if q == "" {
		return nil, nil
	}
	id := int64(-1)
	if n, err := strconv.ParseInt(q, 10, 64); err == nil {
		id = n
	}
	phone := strings.TrimPrefix(strings.ReplaceAll(q, " ", ""), "+")
	phoneRaw := strings.TrimSpace(q)
	username := strings.ToLower(strings.TrimPrefix(q, "@"))
	rows, err := s.pool.Query(ctx, `
WITH auth AS (
	SELECT user_id, max(active_at) AS last_active_at, count(*)::int AS device_count
	FROM authorizations
	GROUP BY user_id
)
SELECT u.id, u.phone, u.username, u.first_name, u.last_name, u.created_at, u.updated_at,
	COALESCE(r.frozen, false), COALESCE(r.reason, ''), u.verified, u.scam, u.fake,
	COALESCE(EXTRACT(EPOCH FROM u.premium_expires_at), 0)::bigint,
	COALESCE(a.last_active_at, '0001-01-01 00:00:00+00'::timestamptz), COALESCE(a.device_count, 0)::int,
	COALESCE(NULLIF(u.username, ''), p.username_lower, '') AS display_username,
	COALESCE(ap.login_email, '')
FROM users u
LEFT JOIN account_restrictions r ON r.user_id = u.id
LEFT JOIN peer_usernames p ON p.peer_type = 'user' AND p.peer_id = u.id
LEFT JOIN auth a ON a.user_id = u.id
LEFT JOIN account_passwords ap ON ap.user_id = u.id
WHERE u.id = $1 OR u.phone = $2 OR u.phone = $3 OR lower(u.username) = $4 OR p.username_lower = $4
ORDER BY u.id
LIMIT $5`, id, phone, phoneRaw, username, accountSearchLimit)
	if err != nil {
		return nil, fmt.Errorf("search accounts: %w", err)
	}
	defer rows.Close()
	out := make([]AccountRow, 0)
	for rows.Next() {
		var item AccountRow
		if err := rows.Scan(&item.ID, &item.Phone, &item.Username, &item.FirstName, &item.LastName, &item.CreatedAt, &item.UpdatedAt, &item.Frozen, &item.Reason, &item.Verified, &item.Scam, &item.Fake, &item.PremiumUntil, &item.LastActiveAt, &item.DeviceCount, &item.Username, &item.LoginEmail); err != nil {
			return nil, err
		}
		out = append(out, item)
	}
	return out, rows.Err()
}

type BotRow struct {
	ID          int64
	Username    string
	FirstName   string
	Verified    bool
	Scam        bool
	Fake        bool
	System      bool
	OwnerUserID int64
	CreatedAt   time.Time
	UpdatedAt   time.Time
}

type BotDetail struct {
	Bot           BotRow
	About         string
	Description   string
	OwnerUsername string
	AuditLogs     []AuditLogRow
}

// ListBots pages over live bot accounts (users.is_bot, not tombstoned) by
// descending id. Bots are excluded from ListAccounts, so this is the dedicated
// projection for them.
func (s *readStore) ListBots(ctx context.Context, beforeID int64, limit int) ([]BotRow, bool, error) {
	if limit <= 0 {
		limit = accountListDefaultLimit
	}
	if limit > accountListMaxLimit {
		limit = accountListMaxLimit
	}
	rows, err := s.pool.Query(ctx, `
SELECT u.id, COALESCE(NULLIF(u.username, ''), p.username_lower, ''), u.first_name, u.verified, u.scam, u.fake,
	COALESCE(b.owner_user_id, 0), u.created_at, u.updated_at
FROM users u
LEFT JOIN bots b ON b.bot_user_id = u.id
LEFT JOIN peer_usernames p ON p.peer_type = 'user' AND p.peer_id = u.id
WHERE u.is_bot AND u.deleted_at IS NULL AND ($1::bigint = 0 OR u.id < $1)
ORDER BY u.id DESC
LIMIT $2`, beforeID, limit+1)
	if err != nil {
		return nil, false, fmt.Errorf("list bots: %w", err)
	}
	defer rows.Close()
	out := make([]BotRow, 0, limit+1)
	for rows.Next() {
		var item BotRow
		if err := rows.Scan(&item.ID, &item.Username, &item.FirstName, &item.Verified, &item.Scam, &item.Fake, &item.OwnerUserID, &item.CreatedAt, &item.UpdatedAt); err != nil {
			return nil, false, err
		}
		item.System = domain.IsSystemUserID(item.ID)
		out = append(out, item)
	}
	if err := rows.Err(); err != nil {
		return nil, false, err
	}
	hasMore := len(out) > limit
	if hasMore {
		out = out[:limit]
	}
	return out, hasMore, nil
}

func (s *readStore) SearchBots(ctx context.Context, q string) ([]BotRow, error) {
	q = strings.TrimSpace(q)
	if q == "" {
		return nil, nil
	}
	id := int64(-1)
	if n, err := strconv.ParseInt(q, 10, 64); err == nil {
		id = n
	}
	username := strings.ToLower(strings.TrimPrefix(q, "@"))
	rows, err := s.pool.Query(ctx, `
SELECT u.id, COALESCE(NULLIF(u.username, ''), p.username_lower, ''), u.first_name, u.verified, u.scam, u.fake,
	COALESCE(b.owner_user_id, 0), u.created_at, u.updated_at
FROM users u
LEFT JOIN bots b ON b.bot_user_id = u.id
LEFT JOIN peer_usernames p ON p.peer_type = 'user' AND p.peer_id = u.id
WHERE u.is_bot AND u.deleted_at IS NULL AND (u.id = $1 OR lower(u.username) = $2 OR p.username_lower = $2)
ORDER BY u.id DESC
LIMIT $3`, id, username, accountSearchLimit)
	if err != nil {
		return nil, fmt.Errorf("search bots: %w", err)
	}
	defer rows.Close()
	out := make([]BotRow, 0)
	for rows.Next() {
		var item BotRow
		if err := rows.Scan(&item.ID, &item.Username, &item.FirstName, &item.Verified, &item.Scam, &item.Fake, &item.OwnerUserID, &item.CreatedAt, &item.UpdatedAt); err != nil {
			return nil, err
		}
		item.System = domain.IsSystemUserID(item.ID)
		out = append(out, item)
	}
	return out, rows.Err()
}

func (s *readStore) BotDetail(ctx context.Context, botUserID int64) (BotDetail, error) {
	var out BotDetail
	err := s.pool.QueryRow(ctx, `
SELECT u.id, COALESCE(NULLIF(u.username, ''), p.username_lower, ''), u.first_name, u.about, u.verified, u.scam, u.fake,
	COALESCE(b.owner_user_id, 0), COALESCE(b.description, ''),
	u.created_at, u.updated_at
FROM users u
LEFT JOIN bots b ON b.bot_user_id = u.id
LEFT JOIN peer_usernames p ON p.peer_type = 'user' AND p.peer_id = u.id
WHERE u.id = $1 AND u.is_bot AND u.deleted_at IS NULL`, botUserID).Scan(
		&out.Bot.ID, &out.Bot.Username, &out.Bot.FirstName, &out.About, &out.Bot.Verified, &out.Bot.Scam, &out.Bot.Fake,
		&out.Bot.OwnerUserID, &out.Description, &out.Bot.CreatedAt, &out.Bot.UpdatedAt,
	)
	if err != nil {
		return out, fmt.Errorf("get bot: %w", err)
	}
	out.Bot.System = domain.IsSystemUserID(out.Bot.ID)
	if out.Bot.OwnerUserID > 0 {
		var ownerUsername string
		if err := s.pool.QueryRow(ctx, `
SELECT COALESCE(NULLIF(u.username, ''), p.username_lower, '')
FROM users u
LEFT JOIN peer_usernames p ON p.peer_type = 'user' AND p.peer_id = u.id
WHERE u.id = $1`, out.Bot.OwnerUserID).Scan(&ownerUsername); err != nil && err != pgx.ErrNoRows {
			return out, fmt.Errorf("get bot owner: %w", err)
		} else {
			out.OwnerUsername = ownerUsername
		}
	}
	out.AuditLogs, err = s.auditLogs(ctx, botUserID)
	if err != nil {
		return out, err
	}
	return out, nil
}

func (s *readStore) SearchChannels(ctx context.Context, q string) ([]ChannelRow, error) {
	q = strings.TrimSpace(q)
	if q == "" {
		return nil, nil
	}
	id := int64(-1)
	if n, err := strconv.ParseInt(q, 10, 64); err == nil {
		id = n
	}
	username := strings.ToLower(strings.TrimPrefix(q, "@"))
	rows, err := s.pool.Query(ctx, `
SELECT c.id, c.access_hash, c.creator_user_id, c.title, c.about,
	COALESCE(NULLIF(c.username, ''), p.username_lower, '') AS display_username,
	c.broadcast, c.megagroup, c.forum, c.monoforum, c.verified, c.scam, c.fake, c.gigagroup, c.deleted,
	c.antispam, c.participants_hidden, c.noforwards, c.join_to_send, c.join_request, c.slowmode_seconds,
	c.participants_count, c.admins_count, c.kicked_count, c.banned_count,
	c.top_message_id, c.pinned_message_id, c.pts, c.date, c.created_at, c.updated_at
FROM channels c
LEFT JOIN peer_usernames p ON p.peer_type = 'channel' AND p.peer_id = c.id
WHERE NOT c.deleted
	AND NOT c.monoforum
	AND (c.broadcast OR c.megagroup)
	AND (
		c.id = $1
		OR lower(COALESCE(c.username, '')) = $2
		OR p.username_lower = $2
		OR lower(c.title) LIKE '%' || $2 || '%'
	)
ORDER BY c.updated_at DESC, c.id DESC
LIMIT $3`, id, username, channelSearchLimit)
	if err != nil {
		return nil, fmt.Errorf("search channels: %w", err)
	}
	defer rows.Close()
	return scanChannelRows(rows)
}

func (s *readStore) ListChannels(ctx context.Context, beforeUpdatedUS, beforeID int64, limit int) ([]ChannelRow, bool, error) {
	if limit <= 0 {
		limit = channelListDefaultLimit
	}
	if limit > channelListMaxLimit {
		limit = channelListMaxLimit
	}
	rows, err := s.pool.Query(ctx, `
SELECT c.id, c.access_hash, c.creator_user_id, c.title, c.about,
	COALESCE(NULLIF(c.username, ''), p.username_lower, '') AS display_username,
	c.broadcast, c.megagroup, c.forum, c.monoforum, c.verified, c.scam, c.fake, c.gigagroup, c.deleted,
	c.antispam, c.participants_hidden, c.noforwards, c.join_to_send, c.join_request, c.slowmode_seconds,
	c.participants_count, c.admins_count, c.kicked_count, c.banned_count,
	c.top_message_id, c.pinned_message_id, c.pts, c.date, c.created_at, c.updated_at
FROM channels c
LEFT JOIN peer_usernames p ON p.peer_type = 'channel' AND p.peer_id = c.id
WHERE NOT c.deleted
	AND NOT c.monoforum
	AND (c.broadcast OR c.megagroup)
	AND ($1::bigint = 0 OR (c.updated_at, c.id) < (to_timestamp(($1::double precision) / 1000000.0), $2::bigint))
ORDER BY c.updated_at DESC, c.id DESC
LIMIT $3`, beforeUpdatedUS, beforeID, limit+1)
	if err != nil {
		return nil, false, fmt.Errorf("list channels: %w", err)
	}
	defer rows.Close()
	out, err := scanChannelRows(rows)
	if err != nil {
		return nil, false, err
	}
	hasMore := len(out) > limit
	if hasMore {
		out = out[:limit]
	}
	return out, hasMore, nil
}

func (s *readStore) ChannelDetail(ctx context.Context, channelID int64) (ChannelDetail, error) {
	var out ChannelDetail
	var raw []byte
	err := s.pool.QueryRow(ctx, `
SELECT c.id, c.access_hash, c.creator_user_id, c.title, c.about,
	COALESCE(NULLIF(c.username, ''), p.username_lower, '') AS display_username,
	c.broadcast, c.megagroup, c.forum, c.monoforum, c.verified, c.scam, c.fake, c.gigagroup, c.deleted,
	c.antispam, c.participants_hidden, c.noforwards, c.join_to_send, c.join_request, c.slowmode_seconds,
	c.participants_count, c.admins_count, c.kicked_count, c.banned_count,
	c.top_message_id, c.pinned_message_id, c.pts, c.date, c.created_at, c.updated_at,
	row_to_json(c)::jsonb
FROM channels c
LEFT JOIN peer_usernames p ON p.peer_type = 'channel' AND p.peer_id = c.id
WHERE c.id = $1
	AND NOT c.deleted
	AND NOT c.monoforum
	AND (c.broadcast OR c.megagroup)`, channelID).Scan(channelScanDestWithRaw(&out.Channel, &raw)...)
	if err != nil {
		return out, fmt.Errorf("get channel: %w", err)
	}
	out.ChannelJSON = prettyJSON(raw)
	out.AuditLogs, err = s.channelAuditLogs(ctx, channelID)
	if err != nil {
		return out, err
	}
	return out, nil
}

type channelScanner interface {
	Scan(dest ...any) error
}

func scanChannelRows(rows pgx.Rows) ([]ChannelRow, error) {
	out := make([]ChannelRow, 0)
	for rows.Next() {
		var item ChannelRow
		if err := scanChannelRow(rows, &item); err != nil {
			return nil, err
		}
		out = append(out, item)
	}
	return out, rows.Err()
}

func scanChannelRow(row channelScanner, item *ChannelRow) error {
	return row.Scan(channelScanDest(item)...)
}

func channelScanDest(item *ChannelRow) []any {
	return []any{
		&item.ID, &item.AccessHash, &item.CreatorUserID, &item.Title, &item.About, &item.Username,
		&item.Broadcast, &item.Megagroup, &item.Forum, &item.Monoforum, &item.Verified, &item.Scam, &item.Fake, &item.Gigagroup, &item.Deleted,
		&item.AntiSpam, &item.ParticipantsHidden, &item.NoForwards, &item.JoinToSend, &item.JoinRequest, &item.SlowmodeSeconds,
		&item.ParticipantsCount, &item.AdminsCount, &item.KickedCount, &item.BannedCount,
		&item.TopMessageID, &item.PinnedMessageID, &item.PTS, &item.Date, &item.CreatedAt, &item.UpdatedAt,
	}
}

func channelScanDestWithRaw(item *ChannelRow, raw *[]byte) []any {
	dest := channelScanDest(item)
	return append(dest, raw)
}

func (s *readStore) ListAccounts(ctx context.Context, beforeActiveUS, beforeID int64, limit int) ([]AccountRow, bool, error) {
	if limit <= 0 {
		limit = accountListDefaultLimit
	}
	if limit > accountListMaxLimit {
		limit = accountListMaxLimit
	}
	rows, err := s.pool.Query(ctx, `
WITH auth AS (
	SELECT user_id, max(active_at) AS last_active_at, count(*)::int AS device_count
	FROM authorizations
	GROUP BY user_id
)
SELECT u.id, u.phone, u.username, u.first_name, u.last_name, u.created_at, u.updated_at,
	COALESCE(r.frozen, false), COALESCE(r.reason, ''), u.verified, u.scam, u.fake,
	COALESCE(EXTRACT(EPOCH FROM u.premium_expires_at), 0)::bigint,
	auth.last_active_at, auth.device_count,
	COALESCE(NULLIF(u.username, ''), p.username_lower, '') AS display_username,
	COALESCE(ap.login_email, '')
FROM users u
JOIN auth ON auth.user_id = u.id
LEFT JOIN account_restrictions r ON r.user_id = u.id
LEFT JOIN peer_usernames p ON p.peer_type = 'user' AND p.peer_id = u.id
LEFT JOIN account_passwords ap ON ap.user_id = u.id
WHERE NOT u.is_bot
	AND ($1::bigint = 0 OR (auth.last_active_at, u.id) < (to_timestamp(($1::double precision) / 1000000.0), $2::bigint))
ORDER BY auth.last_active_at DESC, u.id DESC
LIMIT $3`, beforeActiveUS, beforeID, limit+1)
	if err != nil {
		return nil, false, fmt.Errorf("list accounts: %w", err)
	}
	defer rows.Close()
	out := make([]AccountRow, 0, limit+1)
	for rows.Next() {
		var item AccountRow
		if err := rows.Scan(&item.ID, &item.Phone, &item.Username, &item.FirstName, &item.LastName, &item.CreatedAt, &item.UpdatedAt, &item.Frozen, &item.Reason, &item.Verified, &item.Scam, &item.Fake, &item.PremiumUntil, &item.LastActiveAt, &item.DeviceCount, &item.Username, &item.LoginEmail); err != nil {
			return nil, false, err
		}
		out = append(out, item)
	}
	if err := rows.Err(); err != nil {
		return nil, false, err
	}
	hasMore := len(out) > limit
	if hasMore {
		out = out[:limit]
	}
	return out, hasMore, nil
}

func (s *readStore) AccountDetail(ctx context.Context, userID int64) (AccountDetail, error) {
	var out AccountDetail
	err := s.pool.QueryRow(ctx, `
SELECT u.id, u.phone, u.username, u.first_name, u.last_name, u.created_at, u.updated_at,
	u.about, u.last_seen_at, u.verified, u.scam, u.fake, u.support, u.is_bot,
	COALESCE(r.frozen, false), COALESCE(r.reason, ''),
	COALESCE(EXTRACT(EPOCH FROM u.premium_expires_at), 0)::bigint,
	COALESCE(sb.balance, 0)::bigint, COALESCE(sb.granted, false),
	COALESCE(NULLIF(u.username, ''), p.username_lower, '') AS display_username
FROM users u
LEFT JOIN account_restrictions r ON r.user_id = u.id
LEFT JOIN stars_balances sb ON sb.user_id = u.id
LEFT JOIN peer_usernames p ON p.peer_type = 'user' AND p.peer_id = u.id
WHERE u.id = $1`, userID).Scan(
		&out.Account.ID, &out.Account.Phone, &out.Account.Username, &out.Account.FirstName, &out.Account.LastName,
		&out.Account.CreatedAt, &out.Account.UpdatedAt, &out.About, &out.LastSeenAt, &out.Verified, &out.Scam, &out.Fake, &out.Support, &out.Bot,
		&out.Account.Frozen, &out.Account.Reason, &out.Account.PremiumUntil, &out.StarsBalance, &out.StarsGranted, &out.Account.Username,
	)
	if err != nil {
		return out, fmt.Errorf("get account: %w", err)
	}
	out.Restriction, out.HasRestriction, err = s.restriction(ctx, userID)
	if err != nil {
		return out, err
	}
	out.Authorizations, err = s.authorizations(ctx, userID)
	if err != nil {
		return out, err
	}
	out.AuditLogs, err = s.auditLogs(ctx, userID)
	if err != nil {
		return out, err
	}
	return out, nil
}

func (s *readStore) restriction(ctx context.Context, userID int64) (RestrictionRow, bool, error) {
	var r RestrictionRow
	err := s.pool.QueryRow(ctx, `
SELECT frozen, frozen_since, frozen_until, appeal_url, reason, actor, command_id, updated_at
FROM account_restrictions
WHERE user_id = $1`, userID).Scan(
		&r.Frozen, &r.Since, &r.Until, &r.AppealURL,
		&r.Reason, &r.Actor, &r.CommandID, &r.UpdatedAt,
	)
	if err != nil {
		if err == pgx.ErrNoRows {
			return RestrictionRow{}, false, nil
		}
		return RestrictionRow{}, false, fmt.Errorf("get restriction: %w", err)
	}
	return r, true, nil
}

func (s *readStore) authorizations(ctx context.Context, userID int64) ([]AuthorizationRow, error) {
	rows, err := s.pool.Query(ctx, `
SELECT auth_key_id, hash, layer, device_model, platform, system_version, api_id, app_version, ip, password_pending, created_at, active_at
FROM authorizations
WHERE user_id = $1
ORDER BY active_at DESC, created_at DESC
LIMIT 100`, userID)
	if err != nil {
		return nil, fmt.Errorf("list authorizations: %w", err)
	}
	defer rows.Close()
	out := make([]AuthorizationRow, 0)
	for rows.Next() {
		var a AuthorizationRow
		if err := rows.Scan(&a.AuthKeyID, &a.Hash, &a.Layer, &a.DeviceModel, &a.Platform, &a.SystemVersion, &a.APIID, &a.AppVersion, &a.IP, &a.PasswordPending, &a.CreatedAt, &a.ActiveAt); err != nil {
			return nil, err
		}
		out = append(out, a)
	}
	return out, rows.Err()
}

func (s *readStore) auditLogs(ctx context.Context, userID int64) ([]AuditLogRow, error) {
	rows, err := s.pool.Query(ctx, `
SELECT id, command_id, actor, action, dry_run, reason, status, error, result, created_at
FROM admin_audit_logs
WHERE target_user_id = $1
ORDER BY id DESC
LIMIT 30`, userID)
	if err != nil {
		return nil, fmt.Errorf("list audit logs: %w", err)
	}
	defer rows.Close()
	out := make([]AuditLogRow, 0)
	for rows.Next() {
		var a AuditLogRow
		var result []byte
		if err := rows.Scan(&a.ID, &a.CommandID, &a.Actor, &a.Action, &a.DryRun, &a.Reason, &a.Status, &a.Error, &result, &a.CreatedAt); err != nil {
			return nil, err
		}
		a.Result = prettyJSON(result)
		out = append(out, a)
	}
	return out, rows.Err()
}

func (s *readStore) channelAuditLogs(ctx context.Context, channelID int64) ([]AuditLogRow, error) {
	rows, err := s.pool.Query(ctx, `
SELECT id, command_id, actor, action, dry_run, reason, status, error, result, created_at
FROM admin_audit_logs
WHERE target_peer_type = 'channel' AND target_peer_id = $1
ORDER BY id DESC
LIMIT 30`, channelID)
	if err != nil {
		return nil, fmt.Errorf("list channel audit logs: %w", err)
	}
	defer rows.Close()
	out := make([]AuditLogRow, 0)
	for rows.Next() {
		var a AuditLogRow
		var result []byte
		if err := rows.Scan(&a.ID, &a.CommandID, &a.Actor, &a.Action, &a.DryRun, &a.Reason, &a.Status, &a.Error, &result, &a.CreatedAt); err != nil {
			return nil, err
		}
		a.Result = prettyJSON(result)
		out = append(out, a)
	}
	return out, rows.Err()
}

type MessageRow struct {
	OwnerUserID      int64
	BoxID            int
	PrivateMessageID int64
	MessageSenderID  int64
	PeerID           int64
	FromUserID       int64
	Date             int64
	Outgoing         bool
	Body             string
	PTS              int
	Deleted          bool
	Media            string
}

type GroupMessageRow struct {
	ChannelID    int64
	ID           int
	SenderUserID int64
	FromPeerType string
	FromPeerID   int64
	Date         int64
	Post         bool
	Body         string
	PTS          int
	Deleted      bool
	Media        string
	ViewsCount   int
	EditDate     int
	Pinned       bool
}

func (s *readStore) ListMessages(ctx context.Context, ownerUserID, peerID int64, beforeDate int64, beforeID int, limit int) ([]MessageRow, error) {
	if limit <= 0 || limit > messagePageLimit {
		limit = messagePageLimit
	}
	rows, err := s.pool.Query(ctx, `
SELECT owner_user_id, box_id, private_message_id, message_sender_id, peer_id, from_user_id,
	message_date, outgoing, body, pts, deleted, COALESCE(media, '{}'::jsonb)
FROM message_boxes
WHERE owner_user_id = $1 AND peer_type = 'user' AND peer_id = $2
	AND ($3::bigint = 0 OR (message_date, box_id) < ($3::bigint, $4::int))
ORDER BY message_date DESC, box_id DESC
LIMIT $5`, ownerUserID, peerID, beforeDate, beforeID, limit)
	if err != nil {
		return nil, fmt.Errorf("list messages: %w", err)
	}
	defer rows.Close()
	out := make([]MessageRow, 0)
	for rows.Next() {
		var item MessageRow
		var media []byte
		if err := rows.Scan(&item.OwnerUserID, &item.BoxID, &item.PrivateMessageID, &item.MessageSenderID, &item.PeerID, &item.FromUserID, &item.Date, &item.Outgoing, &item.Body, &item.PTS, &item.Deleted, &media); err != nil {
			return nil, err
		}
		item.Media = prettyJSON(media)
		out = append(out, item)
	}
	return out, rows.Err()
}

func (s *readStore) ListGroupMessages(ctx context.Context, channelID int64, beforeDate int64, beforeID int, limit int) ([]GroupMessageRow, error) {
	if limit <= 0 || limit > messagePageLimit {
		limit = messagePageLimit
	}
	rows, err := s.pool.Query(ctx, `
SELECT channel_id, id, sender_user_id, from_peer_type, from_peer_id,
	message_date, post, body, pts, deleted, COALESCE(media, '{}'::jsonb),
	views_count, edit_date, pinned
FROM channel_messages
WHERE channel_id = $1 AND NOT deleted
	AND ($2::bigint = 0 OR (message_date, id) < ($2::bigint, $3::int))
ORDER BY message_date DESC, id DESC
LIMIT $4`, channelID, beforeDate, beforeID, limit)
	if err != nil {
		return nil, fmt.Errorf("list group messages: %w", err)
	}
	defer rows.Close()
	out := make([]GroupMessageRow, 0)
	for rows.Next() {
		var item GroupMessageRow
		var media []byte
		if err := rows.Scan(&item.ChannelID, &item.ID, &item.SenderUserID, &item.FromPeerType, &item.FromPeerID, &item.Date, &item.Post, &item.Body, &item.PTS, &item.Deleted, &media, &item.ViewsCount, &item.EditDate, &item.Pinned); err != nil {
			return nil, err
		}
		item.Media = prettyJSON(media)
		out = append(out, item)
	}
	return out, rows.Err()
}

type MessageDetail struct {
	Message      MessageRow
	MessageJSON  string
	DialogJSON   string
	PrivateJSON  string
	UpdateEvents []UpdateEventRow
	Outbox       []OutboxRow
}

type GroupMessageDetail struct {
	Message      GroupMessageRow
	MessageJSON  string
	ChannelJSON  string
	UpdateEvents []ChannelUpdateEventRow
}

type UpdateEventRow struct {
	PTS      int
	PTSCount int
	Type     string
	Date     int64
	JSON     string
}

type ChannelUpdateEventRow struct {
	PTS          int
	PTSCount     int
	Type         string
	MessageID    int
	Date         int64
	SenderUserID int64
	JSON         string
}

type OutboxRow struct {
	ID           int64
	TargetUserID int64
	PTS          int
	EventType    string
	Status       string
	Attempts     int
	CreatedAt    time.Time
	UpdatedAt    time.Time
}

func (s *readStore) MessageDetail(ctx context.Context, ownerUserID int64, msgID int) (MessageDetail, error) {
	var out MessageDetail
	var media []byte
	var messageJSON []byte
	err := s.pool.QueryRow(ctx, `
SELECT owner_user_id, box_id, private_message_id, message_sender_id, peer_id, from_user_id,
	message_date, outgoing, body, pts, deleted, COALESCE(media, '{}'::jsonb), row_to_json(mb)::jsonb
FROM message_boxes mb
WHERE owner_user_id = $1 AND box_id = $2`, ownerUserID, msgID).Scan(
		&out.Message.OwnerUserID, &out.Message.BoxID, &out.Message.PrivateMessageID, &out.Message.MessageSenderID, &out.Message.PeerID,
		&out.Message.FromUserID, &out.Message.Date, &out.Message.Outgoing, &out.Message.Body, &out.Message.PTS, &out.Message.Deleted,
		&media, &messageJSON,
	)
	if err != nil {
		return out, fmt.Errorf("get message: %w", err)
	}
	out.Message.Media = prettyJSON(media)
	out.MessageJSON = prettyJSON(messageJSON)
	out.DialogJSON, _ = s.rowJSON(ctx, `SELECT row_to_json(d)::jsonb FROM dialogs d WHERE user_id = $1 AND peer_type = 'user' AND peer_id = $2`, ownerUserID, out.Message.PeerID)
	out.PrivateJSON, _ = s.rowJSON(ctx, `SELECT row_to_json(pm)::jsonb FROM private_messages pm WHERE id = $1`, out.Message.PrivateMessageID)
	events, err := s.updateEvents(ctx, ownerUserID, msgID)
	if err != nil {
		return out, err
	}
	out.UpdateEvents = events
	outbox, err := s.outbox(ctx, ownerUserID, out.Message.PTS)
	if err != nil {
		return out, err
	}
	out.Outbox = outbox
	return out, nil
}

func (s *readStore) GroupMessageDetail(ctx context.Context, channelID int64, msgID int) (GroupMessageDetail, error) {
	var out GroupMessageDetail
	var media []byte
	var messageJSON []byte
	err := s.pool.QueryRow(ctx, `
SELECT channel_id, id, sender_user_id, from_peer_type, from_peer_id,
	message_date, post, body, pts, deleted, COALESCE(media, '{}'::jsonb),
	views_count, edit_date, pinned, row_to_json(cm)::jsonb
FROM channel_messages cm
WHERE channel_id = $1 AND id = $2`, channelID, msgID).Scan(
		&out.Message.ChannelID, &out.Message.ID, &out.Message.SenderUserID, &out.Message.FromPeerType, &out.Message.FromPeerID,
		&out.Message.Date, &out.Message.Post, &out.Message.Body, &out.Message.PTS, &out.Message.Deleted, &media,
		&out.Message.ViewsCount, &out.Message.EditDate, &out.Message.Pinned, &messageJSON,
	)
	if err != nil {
		return out, fmt.Errorf("get group message: %w", err)
	}
	out.Message.Media = prettyJSON(media)
	out.MessageJSON = prettyJSON(messageJSON)
	out.ChannelJSON, _ = s.rowJSON(ctx, `SELECT row_to_json(c)::jsonb FROM channels c WHERE id = $1`, channelID)
	events, err := s.channelUpdateEvents(ctx, channelID, msgID)
	if err != nil {
		return out, err
	}
	out.UpdateEvents = events
	return out, nil
}

func (s *readStore) rowJSON(ctx context.Context, sql string, args ...any) (string, error) {
	var raw []byte
	if err := s.pool.QueryRow(ctx, sql, args...).Scan(&raw); err != nil {
		return "", err
	}
	return prettyJSON(raw), nil
}

func (s *readStore) updateEvents(ctx context.Context, ownerUserID int64, msgID int) ([]UpdateEventRow, error) {
	rows, err := s.pool.Query(ctx, `
SELECT pts, pts_count, event_type, date, row_to_json(e)::jsonb
FROM user_update_events e
WHERE user_id = $1 AND (
	message_box_id = $2 OR message_ids @> $3::jsonb
)
ORDER BY pts DESC
LIMIT 20`, ownerUserID, msgID, fmt.Sprintf("[%d]", msgID))
	if err != nil {
		return nil, fmt.Errorf("list update events: %w", err)
	}
	defer rows.Close()
	out := make([]UpdateEventRow, 0)
	for rows.Next() {
		var e UpdateEventRow
		var raw []byte
		if err := rows.Scan(&e.PTS, &e.PTSCount, &e.Type, &e.Date, &raw); err != nil {
			return nil, err
		}
		e.JSON = prettyJSON(raw)
		out = append(out, e)
	}
	return out, rows.Err()
}

func (s *readStore) channelUpdateEvents(ctx context.Context, channelID int64, msgID int) ([]ChannelUpdateEventRow, error) {
	rows, err := s.pool.Query(ctx, `
SELECT pts, pts_count, event_type, message_id, date, sender_user_id, row_to_json(e)::jsonb
FROM channel_update_events e
WHERE channel_id = $1 AND (
	message_id = $2 OR message_ids @> $3::jsonb
)
ORDER BY pts DESC
LIMIT 20`, channelID, msgID, fmt.Sprintf("[%d]", msgID))
	if err != nil {
		return nil, fmt.Errorf("list channel update events: %w", err)
	}
	defer rows.Close()
	out := make([]ChannelUpdateEventRow, 0)
	for rows.Next() {
		var e ChannelUpdateEventRow
		var raw []byte
		if err := rows.Scan(&e.PTS, &e.PTSCount, &e.Type, &e.MessageID, &e.Date, &e.SenderUserID, &raw); err != nil {
			return nil, err
		}
		e.JSON = prettyJSON(raw)
		out = append(out, e)
	}
	return out, rows.Err()
}

func (s *readStore) outbox(ctx context.Context, targetUserID int64, pts int) ([]OutboxRow, error) {
	rows, err := s.pool.Query(ctx, `
SELECT id, target_user_id, pts, event_type, status, attempts, created_at, updated_at
FROM dispatch_outbox
WHERE target_user_id = $1 AND pts = $2
ORDER BY id DESC
LIMIT 20`, targetUserID, pts)
	if err != nil {
		return nil, fmt.Errorf("list outbox: %w", err)
	}
	defer rows.Close()
	out := make([]OutboxRow, 0)
	for rows.Next() {
		var row OutboxRow
		if err := rows.Scan(&row.ID, &row.TargetUserID, &row.PTS, &row.EventType, &row.Status, &row.Attempts, &row.CreatedAt, &row.UpdatedAt); err != nil {
			return nil, err
		}
		out = append(out, row)
	}
	return out, rows.Err()
}

func prettyJSON(raw []byte) string {
	if len(raw) == 0 {
		return "{}"
	}
	var v any
	if err := json.Unmarshal(raw, &v); err != nil {
		return string(raw)
	}
	out, err := json.MarshalIndent(v, "", "  ")
	if err != nil {
		return string(raw)
	}
	return string(out)
}

// EmojiRow is a custom-emoji document projection for the admin emoji browser.
type EmojiRow struct {
	DocumentID int64 `json:"DocumentID,string"`
	Alt        string
	MimeType   string
	Size       int64
	SetTitle   string
	CreatedAt  time.Time
}

const emojiListDefaultLimit = 60
const emojiListMaxLimit = 200

func scanEmojiRows(rows pgx.Rows) ([]EmojiRow, error) {
	out := make([]EmojiRow, 0)
	for rows.Next() {
		var item EmojiRow
		if err := rows.Scan(&item.DocumentID, &item.Alt, &item.MimeType, &item.Size, &item.CreatedAt, &item.SetTitle); err != nil {
			return nil, err
		}
		out = append(out, item)
	}
	return out, rows.Err()
}

const emojiSelectColumns = `d.id,
	COALESCE((SELECT a->>'alt' FROM jsonb_array_elements(d.attributes) a WHERE a->>'kind' = 'custom_emoji' LIMIT 1), ''),
	d.mime_type, d.size, d.created_at,
	COALESCE((SELECT s.title FROM sticker_sets s WHERE s.emojis AND NOT s.deleted AND s.document_ids @> to_jsonb(d.id) LIMIT 1), '')`

// ListEmoji pages over custom-emoji documents by descending id.
func (s *readStore) ListEmoji(ctx context.Context, beforeID int64, limit int) ([]EmojiRow, bool, error) {
	if limit <= 0 {
		limit = emojiListDefaultLimit
	}
	if limit > emojiListMaxLimit {
		limit = emojiListMaxLimit
	}
	rows, err := s.pool.Query(ctx, `
SELECT `+emojiSelectColumns+`
FROM documents d
WHERE d.attributes @> '[{"kind":"custom_emoji"}]'::jsonb
	AND ($1::bigint = 0 OR d.id < $1)
ORDER BY d.id DESC
LIMIT $2`, beforeID, limit+1)
	if err != nil {
		return nil, false, fmt.Errorf("list emoji: %w", err)
	}
	defer rows.Close()
	out, err := scanEmojiRows(rows)
	if err != nil {
		return nil, false, err
	}
	hasMore := len(out) > limit
	if hasMore {
		out = out[:limit]
	}
	return out, hasMore, nil
}

// SearchEmoji finds custom-emoji documents by document id or emoticon substring.
func (s *readStore) SearchEmoji(ctx context.Context, q string) ([]EmojiRow, error) {
	q = strings.TrimSpace(q)
	if q == "" {
		return nil, nil
	}
	id := int64(-1)
	if n, err := strconv.ParseInt(q, 10, 64); err == nil {
		id = n
	}
	rows, err := s.pool.Query(ctx, `
SELECT `+emojiSelectColumns+`
FROM documents d
WHERE d.attributes @> '[{"kind":"custom_emoji"}]'::jsonb
	AND (d.id = $1 OR EXISTS (
		SELECT 1 FROM jsonb_array_elements(d.attributes) a
		WHERE a->>'kind' = 'custom_emoji' AND a->>'alt' ILIKE '%' || $2 || '%'
	))
ORDER BY d.id DESC
LIMIT $3`, id, q, emojiListMaxLimit)
	if err != nil {
		return nil, fmt.Errorf("search emoji: %w", err)
	}
	defer rows.Close()
	return scanEmojiRows(rows)
}