package postgres

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"hash/fnv"
	"strings"

	"github.com/jackc/pgx/v5"

	"telesrv/internal/domain"
)

func (s *PasswordStore) HasBusinessAutomation(ctx context.Context, userID int64) (bool, error) {
	var exists bool
	err := s.db.QueryRow(ctx, `
SELECT EXISTS (
  SELECT 1
  FROM user_business_profiles
  WHERE user_id = $1
    AND (greeting_message <> '{}'::jsonb OR away_message <> '{}'::jsonb)
  UNION ALL
  SELECT 1
  FROM business_connected_bots
  WHERE owner_user_id = $1
)`, userID).Scan(&exists)
	if err != nil {
		return false, fmt.Errorf("check business automation: %w", err)
	}
	return exists, nil
}

func (s *PasswordStore) GetBusinessProfile(ctx context.Context, userID int64) (domain.BusinessProfile, bool, error) {
	row := s.db.QueryRow(ctx, `
SELECT
  COALESCE(work_hours::text, '{}')::text,
  COALESCE(location::text, '{}')::text,
  COALESCE(intro::text, '{}')::text,
  COALESCE(greeting_message::text, '{}')::text,
  COALESCE(away_message::text, '{}')::text,
  COALESCE(EXTRACT(EPOCH FROM updated_at), 0)::bigint
FROM user_business_profiles
WHERE user_id = $1`, userID)
	var workHoursJSON, locationJSON, introJSON, greetingJSON, awayJSON string
	profile := domain.BusinessProfile{UserID: userID}
	if err := row.Scan(&workHoursJSON, &locationJSON, &introJSON, &greetingJSON, &awayJSON, &profile.UpdatedAtUnix); err != nil {
		if errors.Is(err, pgx.ErrNoRows) {
			return domain.BusinessProfile{}, false, nil
		}
		return domain.BusinessProfile{}, false, fmt.Errorf("get business profile: %w", err)
	}
	if err := decodeNullableJSON(workHoursJSON, &profile.WorkHours); err != nil {
		return domain.BusinessProfile{}, false, fmt.Errorf("decode work hours: %w", err)
	}
	if err := decodeNullableJSON(locationJSON, &profile.Location); err != nil {
		return domain.BusinessProfile{}, false, fmt.Errorf("decode location: %w", err)
	}
	if err := decodeNullableJSON(introJSON, &profile.Intro); err != nil {
		return domain.BusinessProfile{}, false, fmt.Errorf("decode intro: %w", err)
	}
	if err := decodeNullableJSON(greetingJSON, &profile.Greeting); err != nil {
		return domain.BusinessProfile{}, false, fmt.Errorf("decode greeting: %w", err)
	}
	if err := decodeNullableJSON(awayJSON, &profile.Away); err != nil {
		return domain.BusinessProfile{}, false, fmt.Errorf("decode away: %w", err)
	}
	return profile, true, nil
}

func (s *PasswordStore) SaveBusinessProfile(ctx context.Context, profile domain.BusinessProfile) error {
	workHours, err := encodeNullableJSON(profile.WorkHours)
	if err != nil {
		return err
	}
	location, err := encodeNullableJSON(profile.Location)
	if err != nil {
		return err
	}
	intro, err := encodeNullableJSON(profile.Intro)
	if err != nil {
		return err
	}
	greeting, err := encodeNullableJSON(profile.Greeting)
	if err != nil {
		return err
	}
	away, err := encodeNullableJSON(profile.Away)
	if err != nil {
		return err
	}
	if _, err := s.db.Exec(ctx, `
INSERT INTO user_business_profiles (
  user_id, work_hours, location, intro, greeting_message, away_message, updated_at
) VALUES ($1,$2::jsonb,$3::jsonb,$4::jsonb,$5::jsonb,$6::jsonb,now())
ON CONFLICT (user_id) DO UPDATE SET
  work_hours = EXCLUDED.work_hours,
  location = EXCLUDED.location,
  intro = EXCLUDED.intro,
  greeting_message = EXCLUDED.greeting_message,
  away_message = EXCLUDED.away_message,
  updated_at = now()`, profile.UserID, string(workHours), string(location), string(intro), string(greeting), string(away)); err != nil {
		return fmt.Errorf("save business profile: %w", err)
	}
	return nil
}

func (s *PasswordStore) ListBusinessChatLinks(ctx context.Context, ownerUserID int64) ([]domain.BusinessChatLink, error) {
	rows, err := s.db.Query(ctx, `
SELECT slug, owner_user_id, link, message, COALESCE(entities::text, '[]')::text, title, views,
       COALESCE(EXTRACT(EPOCH FROM created_at), 0)::bigint,
       COALESCE(EXTRACT(EPOCH FROM updated_at), 0)::bigint
FROM business_chat_links
WHERE owner_user_id = $1
ORDER BY created_at ASC, slug ASC
LIMIT $2`, ownerUserID, domain.MaxBusinessChatLinks)
	if err != nil {
		return nil, fmt.Errorf("list business chat links: %w", err)
	}
	defer rows.Close()
	out := make([]domain.BusinessChatLink, 0)
	for rows.Next() {
		link, err := scanBusinessChatLink(rows)
		if err != nil {
			return nil, err
		}
		out = append(out, link)
	}
	if err := rows.Err(); err != nil {
		return nil, fmt.Errorf("scan business chat links: %w", err)
	}
	return out, nil
}

func (s *PasswordStore) CreateBusinessChatLink(ctx context.Context, link domain.BusinessChatLink) (domain.BusinessChatLink, error) {
	return link, withTx(ctx, s.db, "create business chat link", func(tx pgx.Tx) error {
		var count int
		if err := tx.QueryRow(ctx, `SELECT COUNT(*)::int FROM business_chat_links WHERE owner_user_id = $1`, link.OwnerUserID).Scan(&count); err != nil {
			return fmt.Errorf("count business chat links: %w", err)
		}
		if count >= domain.MaxBusinessChatLinks {
			return domain.ErrBusinessChatLinksTooMuch
		}
		entities, err := encodeMessageEntities(link.Entities)
		if err != nil {
			return err
		}
		row := tx.QueryRow(ctx, `
INSERT INTO business_chat_links (slug, owner_user_id, link, message, entities, title, views, created_at, updated_at)
VALUES ($1,$2,$3,$4,$5::jsonb,$6,$7,now(),now())
RETURNING slug, owner_user_id, link, message, COALESCE(entities::text, '[]')::text, title, views,
          COALESCE(EXTRACT(EPOCH FROM created_at), 0)::bigint,
          COALESCE(EXTRACT(EPOCH FROM updated_at), 0)::bigint`,
			link.Slug, link.OwnerUserID, link.Link, link.Message, string(entities), link.Title, link.Views)
		saved, err := scanBusinessChatLink(row)
		if err != nil {
			return fmt.Errorf("insert business chat link: %w", err)
		}
		link = saved
		return nil
	})
}

func (s *PasswordStore) UpdateBusinessChatLink(ctx context.Context, ownerUserID int64, slug string, input domain.BusinessChatLinkInput) (domain.BusinessChatLink, error) {
	entities, err := encodeMessageEntities(input.Entities)
	if err != nil {
		return domain.BusinessChatLink{}, err
	}
	row := s.db.QueryRow(ctx, `
UPDATE business_chat_links
SET message = $3,
    entities = $4::jsonb,
    title = $5,
    updated_at = now()
WHERE owner_user_id = $1
  AND slug = $2
RETURNING slug, owner_user_id, link, message, COALESCE(entities::text, '[]')::text, title, views,
          COALESCE(EXTRACT(EPOCH FROM created_at), 0)::bigint,
          COALESCE(EXTRACT(EPOCH FROM updated_at), 0)::bigint`, ownerUserID, slug, input.Message, string(entities), input.Title)
	link, err := scanBusinessChatLink(row)
	if err != nil {
		if errors.Is(err, pgx.ErrNoRows) {
			return domain.BusinessChatLink{}, domain.ErrBusinessChatLinkNotFound
		}
		return domain.BusinessChatLink{}, fmt.Errorf("update business chat link: %w", err)
	}
	return link, nil
}

func (s *PasswordStore) DeleteBusinessChatLink(ctx context.Context, ownerUserID int64, slug string) (bool, error) {
	tag, err := s.db.Exec(ctx, `DELETE FROM business_chat_links WHERE owner_user_id = $1 AND slug = $2`, ownerUserID, slug)
	if err != nil {
		return false, fmt.Errorf("delete business chat link: %w", err)
	}
	return tag.RowsAffected() > 0, nil
}

func (s *PasswordStore) ResolveBusinessChatLink(ctx context.Context, slug string, bumpViews bool) (domain.BusinessChatLink, bool, error) {
	sqlText := `
SELECT slug, owner_user_id, link, message, COALESCE(entities::text, '[]')::text, title, views,
       COALESCE(EXTRACT(EPOCH FROM created_at), 0)::bigint,
       COALESCE(EXTRACT(EPOCH FROM updated_at), 0)::bigint
FROM business_chat_links
WHERE slug = $1`
	if bumpViews {
		sqlText = `
UPDATE business_chat_links
SET views = views + 1,
    updated_at = now()
WHERE slug = $1
RETURNING slug, owner_user_id, link, message, COALESCE(entities::text, '[]')::text, title, views,
          COALESCE(EXTRACT(EPOCH FROM created_at), 0)::bigint,
          COALESCE(EXTRACT(EPOCH FROM updated_at), 0)::bigint`
	}
	link, err := scanBusinessChatLink(s.db.QueryRow(ctx, sqlText, slug))
	if err != nil {
		if errors.Is(err, pgx.ErrNoRows) {
			return domain.BusinessChatLink{}, false, nil
		}
		return domain.BusinessChatLink{}, false, fmt.Errorf("resolve business chat link: %w", err)
	}
	return link, true, nil
}

func (s *PasswordStore) ListQuickReplies(ctx context.Context, ownerUserID int64, includeTopMessages bool) (domain.QuickReplyList, error) {
	replies, err := s.listQuickReplies(ctx, ownerUserID)
	if err != nil {
		return domain.QuickReplyList{}, err
	}
	messages := make([]domain.QuickReplyMessage, 0, len(replies))
	if includeTopMessages {
		for _, reply := range replies {
			if reply.TopMessage == 0 {
				continue
			}
			msgs, err := s.GetQuickReplyMessages(ctx, ownerUserID, reply.ID, []int{reply.TopMessage})
			if err != nil {
				return domain.QuickReplyList{}, err
			}
			messages = append(messages, msgs.Messages...)
		}
	}
	return domain.QuickReplyList{
		OwnerUserID:  ownerUserID,
		QuickReplies: replies,
		Messages:     messages,
		Hash:         postgresQuickReplyListHash(replies),
	}, nil
}

func (s *PasswordStore) CheckQuickReplyShortcut(ctx context.Context, ownerUserID int64, shortcut string) (bool, error) {
	shortcut, err := domain.NormalizeQuickReplyShortcut(shortcut)
	if err != nil {
		return false, err
	}
	var id int
	err = s.db.QueryRow(ctx, `SELECT shortcut_id FROM quick_replies WHERE owner_user_id = $1 AND lower(shortcut) = lower($2)`, ownerUserID, shortcut).Scan(&id)
	if errors.Is(err, pgx.ErrNoRows) {
		return true, nil
	}
	if err != nil {
		return false, fmt.Errorf("check quick reply shortcut: %w", err)
	}
	return false, nil
}

func (s *PasswordStore) SaveQuickReplyText(ctx context.Context, ownerUserID int64, shortcut string, msg domain.QuickReplyMessage) (domain.QuickReplyMutation, error) {
	shortcut, err := domain.NormalizeQuickReplyShortcut(shortcut)
	if err != nil {
		return domain.QuickReplyMutation{}, err
	}
	var mutation domain.QuickReplyMutation
	err = withTx(ctx, s.db, "save quick reply text", func(tx pgx.Tx) error {
		shortcutID, created, err := ensureQuickReplyShortcut(ctx, tx, ownerUserID, shortcut)
		if err != nil {
			return err
		}
		var count int
		if err := tx.QueryRow(ctx, `SELECT COUNT(*)::int FROM quick_reply_messages WHERE owner_user_id = $1 AND shortcut_id = $2`, ownerUserID, shortcutID).Scan(&count); err != nil {
			return fmt.Errorf("count quick reply messages: %w", err)
		}
		if count >= domain.MaxQuickReplyMessages {
			return domain.ErrShortcutInvalid
		}
		var messageID int
		if err := tx.QueryRow(ctx, `SELECT COALESCE(MAX(message_id), 0)::int + 1 FROM quick_reply_messages WHERE owner_user_id = $1`, ownerUserID).Scan(&messageID); err != nil {
			return fmt.Errorf("allocate quick reply message id: %w", err)
		}
		entities, err := encodeMessageEntities(msg.Entities)
		if err != nil {
			return err
		}
		if _, err := tx.Exec(ctx, `
INSERT INTO quick_reply_messages (owner_user_id, shortcut_id, message_id, random_id, message_date, body, entities, created_at, updated_at)
VALUES ($1,$2,$3,$4,$5,$6,$7::jsonb,now(),now())`,
			ownerUserID, shortcutID, messageID, msg.RandomID, msg.Date, msg.Message, string(entities)); err != nil {
			return fmt.Errorf("insert quick reply message: %w", err)
		}
		replies, err := listQuickRepliesTx(ctx, tx, ownerUserID)
		if err != nil {
			return err
		}
		message := domain.QuickReplyMessage{
			OwnerUserID: ownerUserID,
			ShortcutID:  shortcutID,
			ID:          messageID,
			RandomID:    msg.RandomID,
			Date:        msg.Date,
			Message:     msg.Message,
			Entities:    append([]domain.MessageEntity(nil), msg.Entities...),
		}
		reply := quickReplyByID(replies, shortcutID)
		kind := domain.QuickReplyMutationMessage
		if created {
			kind = domain.QuickReplyMutationNew
		}
		mutation = domain.QuickReplyMutation{
			Kind:       kind,
			List:       domain.QuickReplyList{OwnerUserID: ownerUserID, QuickReplies: replies, Messages: []domain.QuickReplyMessage{message}, Hash: postgresQuickReplyListHash(replies)},
			QuickReply: reply,
			ShortcutID: shortcutID,
			Message:    message,
		}
		return nil
	})
	if err != nil {
		return domain.QuickReplyMutation{}, err
	}
	return mutation, nil
}

func (s *PasswordStore) GetQuickReplyMessages(ctx context.Context, ownerUserID int64, shortcutID int, ids []int) (domain.QuickReplyMessages, error) {
	if err := s.ensureQuickReplyExists(ctx, ownerUserID, shortcutID); err != nil {
		return domain.QuickReplyMessages{}, err
	}
	args := []any{ownerUserID, shortcutID}
	filter := ""
	if len(ids) > 0 {
		ids32 := make([]int32, len(ids))
		for i, id := range ids {
			ids32[i] = int32(id)
		}
		filter = " AND message_id = ANY($3::int[])"
		args = append(args, ids32)
	}
	rows, err := s.db.Query(ctx, `
SELECT message_id, random_id, message_date, body, COALESCE(entities::text, '[]')::text
FROM quick_reply_messages
WHERE owner_user_id = $1
  AND shortcut_id = $2`+filter+`
ORDER BY message_id ASC`, args...)
	if err != nil {
		return domain.QuickReplyMessages{}, fmt.Errorf("list quick reply messages: %w", err)
	}
	defer rows.Close()
	out := domain.QuickReplyMessages{OwnerUserID: ownerUserID, ShortcutID: shortcutID}
	for rows.Next() {
		msg, err := scanQuickReplyMessage(ownerUserID, shortcutID, rows)
		if err != nil {
			return domain.QuickReplyMessages{}, err
		}
		out.Messages = append(out.Messages, msg)
	}
	if err := rows.Err(); err != nil {
		return domain.QuickReplyMessages{}, fmt.Errorf("scan quick reply messages: %w", err)
	}
	var total int
	if err := s.db.QueryRow(ctx, `SELECT COUNT(*)::int FROM quick_reply_messages WHERE owner_user_id = $1 AND shortcut_id = $2`, ownerUserID, shortcutID).Scan(&total); err != nil {
		return domain.QuickReplyMessages{}, fmt.Errorf("count quick reply messages: %w", err)
	}
	if len(ids) > 0 && len(out.Messages) != len(ids) {
		return domain.QuickReplyMessages{}, domain.ErrShortcutInvalid
	}
	out.Count = total
	out.Hash = postgresQuickReplyMessagesHash(out.Messages)
	return out, nil
}

func (s *PasswordStore) RenameQuickReplyShortcut(ctx context.Context, ownerUserID int64, shortcutID int, shortcut string) (domain.QuickReplyMutation, error) {
	shortcut, err := domain.NormalizeQuickReplyShortcut(shortcut)
	if err != nil {
		return domain.QuickReplyMutation{}, err
	}
	tag, err := s.db.Exec(ctx, `
UPDATE quick_replies
SET shortcut = $3,
    updated_at = now()
WHERE owner_user_id = $1
  AND shortcut_id = $2`, ownerUserID, shortcutID, shortcut)
	if err != nil {
		return domain.QuickReplyMutation{}, quickReplyPGErr(err)
	}
	if tag.RowsAffected() == 0 {
		return domain.QuickReplyMutation{}, domain.ErrShortcutInvalid
	}
	list, err := s.ListQuickReplies(ctx, ownerUserID, true)
	if err != nil {
		return domain.QuickReplyMutation{}, err
	}
	return domain.QuickReplyMutation{Kind: domain.QuickReplyMutationList, List: list}, nil
}

func (s *PasswordStore) ReorderQuickReplies(ctx context.Context, ownerUserID int64, order []int) (domain.QuickReplyMutation, error) {
	err := withTx(ctx, s.db, "reorder quick replies", func(tx pgx.Tx) error {
		replies, err := listQuickRepliesTx(ctx, tx, ownerUserID)
		if err != nil {
			return err
		}
		if len(order) != len(replies) {
			return domain.ErrShortcutInvalid
		}
		seen := make(map[int]struct{}, len(order))
		byID := make(map[int]struct{}, len(replies))
		for _, reply := range replies {
			byID[reply.ID] = struct{}{}
		}
		for i, id := range order {
			if _, ok := byID[id]; !ok {
				return domain.ErrShortcutInvalid
			}
			if _, ok := seen[id]; ok {
				return domain.ErrShortcutInvalid
			}
			seen[id] = struct{}{}
			if _, err := tx.Exec(ctx, `UPDATE quick_replies SET sort_order = $3, updated_at = now() WHERE owner_user_id = $1 AND shortcut_id = $2`, ownerUserID, id, i+1); err != nil {
				return fmt.Errorf("update quick reply order: %w", err)
			}
		}
		return nil
	})
	if err != nil {
		return domain.QuickReplyMutation{}, err
	}
	list, err := s.ListQuickReplies(ctx, ownerUserID, true)
	if err != nil {
		return domain.QuickReplyMutation{}, err
	}
	return domain.QuickReplyMutation{Kind: domain.QuickReplyMutationList, List: list}, nil
}

func (s *PasswordStore) DeleteQuickReplyShortcut(ctx context.Context, ownerUserID int64, shortcutID int) (domain.QuickReplyMutation, error) {
	tag, err := s.db.Exec(ctx, `DELETE FROM quick_replies WHERE owner_user_id = $1 AND shortcut_id = $2`, ownerUserID, shortcutID)
	if err != nil {
		return domain.QuickReplyMutation{}, fmt.Errorf("delete quick reply shortcut: %w", err)
	}
	if tag.RowsAffected() == 0 {
		return domain.QuickReplyMutation{}, domain.ErrShortcutInvalid
	}
	_ = s.normalizeQuickReplyOrder(ctx, ownerUserID)
	list, err := s.ListQuickReplies(ctx, ownerUserID, true)
	if err != nil {
		return domain.QuickReplyMutation{}, err
	}
	return domain.QuickReplyMutation{Kind: domain.QuickReplyMutationDelete, List: list, ShortcutID: shortcutID}, nil
}

func (s *PasswordStore) DeleteQuickReplyMessages(ctx context.Context, ownerUserID int64, shortcutID int, ids []int) (domain.QuickReplyMutation, error) {
	if len(ids) == 0 {
		return domain.QuickReplyMutation{}, domain.ErrShortcutInvalid
	}
	if err := s.ensureQuickReplyExists(ctx, ownerUserID, shortcutID); err != nil {
		return domain.QuickReplyMutation{}, err
	}
	ids32 := make([]int32, len(ids))
	for i, id := range ids {
		ids32[i] = int32(id)
	}
	tag, err := s.db.Exec(ctx, `DELETE FROM quick_reply_messages WHERE owner_user_id = $1 AND shortcut_id = $2 AND message_id = ANY($3::int[])`, ownerUserID, shortcutID, ids32)
	if err != nil {
		return domain.QuickReplyMutation{}, fmt.Errorf("delete quick reply messages: %w", err)
	}
	if int(tag.RowsAffected()) != len(ids) {
		return domain.QuickReplyMutation{}, domain.ErrShortcutInvalid
	}
	list, err := s.ListQuickReplies(ctx, ownerUserID, true)
	if err != nil {
		return domain.QuickReplyMutation{}, err
	}
	return domain.QuickReplyMutation{Kind: domain.QuickReplyMutationIDs, List: list, ShortcutID: shortcutID, MessageIDs: append([]int(nil), ids...)}, nil
}

func (s *PasswordStore) ReserveBusinessAutomationDelivery(ctx context.Context, delivery domain.BusinessAutomationDelivery) (bool, error) {
	if delivery.OwnerUserID == 0 || delivery.PeerUserID == 0 || delivery.Kind == "" || delivery.TriggerMessageID == 0 {
		return false, domain.ErrBusinessProfileInvalid
	}
	tag, err := s.db.Exec(ctx, `
INSERT INTO business_automation_deliveries (
  owner_user_id, peer_user_id, kind, trigger_message_id, shortcut_id, sent_at, created_at
) VALUES ($1,$2,$3,$4,$5,$6,now())
ON CONFLICT (owner_user_id, peer_user_id, kind, trigger_message_id) DO NOTHING`,
		delivery.OwnerUserID, delivery.PeerUserID, string(delivery.Kind), delivery.TriggerMessageID, delivery.ShortcutID, delivery.SentAt)
	if err != nil {
		return false, fmt.Errorf("reserve business automation delivery: %w", err)
	}
	return tag.RowsAffected() > 0, nil
}

func (s *PasswordStore) LastBusinessAutomationDelivery(ctx context.Context, ownerUserID, peerUserID int64, kind domain.BusinessAutomationKind) (domain.BusinessAutomationDelivery, bool, error) {
	row := s.db.QueryRow(ctx, `
SELECT owner_user_id, peer_user_id, kind, trigger_message_id, shortcut_id, sent_at
FROM business_automation_deliveries
WHERE owner_user_id = $1
  AND peer_user_id = $2
  AND kind = $3
ORDER BY sent_at DESC, trigger_message_id DESC
LIMIT 1`, ownerUserID, peerUserID, string(kind))
	var out domain.BusinessAutomationDelivery
	var kindText string
	if err := row.Scan(&out.OwnerUserID, &out.PeerUserID, &kindText, &out.TriggerMessageID, &out.ShortcutID, &out.SentAt); err != nil {
		if errors.Is(err, pgx.ErrNoRows) {
			return domain.BusinessAutomationDelivery{}, false, nil
		}
		return domain.BusinessAutomationDelivery{}, false, fmt.Errorf("last business automation delivery: %w", err)
	}
	out.Kind = domain.BusinessAutomationKind(kindText)
	return out, true, nil
}

func (s *PasswordStore) GetConnectedBusinessBot(ctx context.Context, ownerUserID int64) (domain.ConnectedBusinessBot, bool, error) {
	row := s.db.QueryRow(ctx, `
SELECT owner_user_id, bot_user_id, COALESCE(recipients::text, '{}')::text, COALESCE(rights::text, '{}')::text,
       COALESCE(EXTRACT(EPOCH FROM created_at), 0)::bigint,
       COALESCE(EXTRACT(EPOCH FROM updated_at), 0)::bigint
FROM business_connected_bots
WHERE owner_user_id = $1`, ownerUserID)
	bot, err := scanConnectedBusinessBot(row)
	if err != nil {
		if errors.Is(err, pgx.ErrNoRows) {
			return domain.ConnectedBusinessBot{}, false, nil
		}
		return domain.ConnectedBusinessBot{}, false, fmt.Errorf("get connected business bot: %w", err)
	}
	return bot, true, nil
}

func (s *PasswordStore) SaveConnectedBusinessBot(ctx context.Context, bot domain.ConnectedBusinessBot) (domain.ConnectedBusinessBot, error) {
	recipients, err := json.Marshal(bot.Recipients)
	if err != nil {
		return domain.ConnectedBusinessBot{}, fmt.Errorf("encode connected business bot recipients: %w", err)
	}
	rights, err := json.Marshal(bot.Rights)
	if err != nil {
		return domain.ConnectedBusinessBot{}, fmt.Errorf("encode connected business bot rights: %w", err)
	}
	row := s.db.QueryRow(ctx, `
INSERT INTO business_connected_bots (owner_user_id, bot_user_id, recipients, rights, created_at, updated_at)
VALUES ($1,$2,$3::jsonb,$4::jsonb,now(),now())
ON CONFLICT (owner_user_id) DO UPDATE SET
  bot_user_id = EXCLUDED.bot_user_id,
  recipients = EXCLUDED.recipients,
  rights = EXCLUDED.rights,
  updated_at = now()
RETURNING owner_user_id, bot_user_id, COALESCE(recipients::text, '{}')::text, COALESCE(rights::text, '{}')::text,
          COALESCE(EXTRACT(EPOCH FROM created_at), 0)::bigint,
          COALESCE(EXTRACT(EPOCH FROM updated_at), 0)::bigint`, bot.OwnerUserID, bot.BotUserID, string(recipients), string(rights))
	saved, err := scanConnectedBusinessBot(row)
	if err != nil {
		return domain.ConnectedBusinessBot{}, fmt.Errorf("save connected business bot: %w", err)
	}
	return saved, nil
}

func (s *PasswordStore) DeleteConnectedBusinessBot(ctx context.Context, ownerUserID, botUserID int64) (bool, error) {
	deleted := false
	err := withTx(ctx, s.db, "delete connected business bot", func(tx pgx.Tx) error {
		tag, err := tx.Exec(ctx, `DELETE FROM business_connected_bots WHERE owner_user_id = $1 AND bot_user_id = $2`, ownerUserID, botUserID)
		if err != nil {
			return fmt.Errorf("delete connected business bot: %w", err)
		}
		deleted = tag.RowsAffected() > 0
		if !deleted {
			return nil
		}
		if _, err := tx.Exec(ctx, `DELETE FROM business_connected_bot_peer_states WHERE owner_user_id = $1`, ownerUserID); err != nil {
			return fmt.Errorf("delete connected business bot peer states: %w", err)
		}
		return nil
	})
	if err != nil {
		return false, err
	}
	return deleted, nil
}

func (s *PasswordStore) SetConnectedBusinessBotPaused(ctx context.Context, ownerUserID, peerUserID int64, paused bool) (domain.ConnectedBusinessBotPeerState, error) {
	row := s.db.QueryRow(ctx, `
INSERT INTO business_connected_bot_peer_states (owner_user_id, peer_user_id, paused, disabled, created_at, updated_at)
VALUES ($1,$2,$3,false,now(),now())
ON CONFLICT (owner_user_id, peer_user_id) DO UPDATE SET
  paused = EXCLUDED.paused,
  updated_at = now()
RETURNING owner_user_id, peer_user_id, paused, disabled,
          COALESCE(EXTRACT(EPOCH FROM updated_at), 0)::bigint`, ownerUserID, peerUserID, paused)
	state, err := scanConnectedBusinessBotPeerState(row)
	if err != nil {
		return domain.ConnectedBusinessBotPeerState{}, fmt.Errorf("set connected business bot paused: %w", err)
	}
	return state, nil
}

func (s *PasswordStore) DisableConnectedBusinessBotForPeer(ctx context.Context, ownerUserID, peerUserID int64) (domain.ConnectedBusinessBotPeerState, error) {
	row := s.db.QueryRow(ctx, `
INSERT INTO business_connected_bot_peer_states (owner_user_id, peer_user_id, paused, disabled, created_at, updated_at)
VALUES ($1,$2,false,true,now(),now())
ON CONFLICT (owner_user_id, peer_user_id) DO UPDATE SET
  paused = false,
  disabled = true,
  updated_at = now()
RETURNING owner_user_id, peer_user_id, paused, disabled,
          COALESCE(EXTRACT(EPOCH FROM updated_at), 0)::bigint`, ownerUserID, peerUserID)
	state, err := scanConnectedBusinessBotPeerState(row)
	if err != nil {
		return domain.ConnectedBusinessBotPeerState{}, fmt.Errorf("disable connected business bot for peer: %w", err)
	}
	return state, nil
}

func (s *PasswordStore) GetConnectedBusinessBotPeerState(ctx context.Context, ownerUserID, peerUserID int64) (domain.ConnectedBusinessBotPeerState, bool, error) {
	row := s.db.QueryRow(ctx, `
SELECT owner_user_id, peer_user_id, paused, disabled,
       COALESCE(EXTRACT(EPOCH FROM updated_at), 0)::bigint
FROM business_connected_bot_peer_states
WHERE owner_user_id = $1
  AND peer_user_id = $2`, ownerUserID, peerUserID)
	state, err := scanConnectedBusinessBotPeerState(row)
	if err != nil {
		if errors.Is(err, pgx.ErrNoRows) {
			return domain.ConnectedBusinessBotPeerState{}, false, nil
		}
		return domain.ConnectedBusinessBotPeerState{}, false, fmt.Errorf("get connected business bot peer state: %w", err)
	}
	return state, true, nil
}

func (s *PasswordStore) listQuickReplies(ctx context.Context, ownerUserID int64) ([]domain.QuickReply, error) {
	return listQuickRepliesDB(ctx, s.db, ownerUserID)
}

func listQuickRepliesTx(ctx context.Context, tx pgx.Tx, ownerUserID int64) ([]domain.QuickReply, error) {
	return listQuickRepliesDB(ctx, tx, ownerUserID)
}

func listQuickRepliesDB(ctx context.Context, db interface {
	Query(context.Context, string, ...interface{}) (pgx.Rows, error)
}, ownerUserID int64) ([]domain.QuickReply, error) {
	rows, err := db.Query(ctx, `
SELECT qr.shortcut_id, qr.shortcut, qr.sort_order,
       COALESCE(MAX(qm.message_id), 0)::int AS top_message,
       COUNT(qm.message_id)::int AS message_count,
       COALESCE(EXTRACT(EPOCH FROM qr.created_at), 0)::bigint,
       COALESCE(EXTRACT(EPOCH FROM qr.updated_at), 0)::bigint
FROM quick_replies qr
LEFT JOIN quick_reply_messages qm
  ON qm.owner_user_id = qr.owner_user_id
 AND qm.shortcut_id = qr.shortcut_id
WHERE qr.owner_user_id = $1
GROUP BY qr.shortcut_id, qr.shortcut, qr.sort_order, qr.created_at, qr.updated_at
ORDER BY qr.sort_order ASC, qr.shortcut_id ASC
LIMIT $2`, ownerUserID, domain.MaxQuickReplies)
	if err != nil {
		return nil, fmt.Errorf("list quick replies: %w", err)
	}
	defer rows.Close()
	out := make([]domain.QuickReply, 0)
	for rows.Next() {
		var item domain.QuickReply
		item.OwnerUserID = ownerUserID
		if err := rows.Scan(&item.ID, &item.Shortcut, &item.SortOrder, &item.TopMessage, &item.Count, &item.CreatedAt, &item.UpdatedAt); err != nil {
			return nil, fmt.Errorf("scan quick reply: %w", err)
		}
		out = append(out, item)
	}
	if err := rows.Err(); err != nil {
		return nil, fmt.Errorf("scan quick replies: %w", err)
	}
	return out, nil
}

func ensureQuickReplyShortcut(ctx context.Context, tx pgx.Tx, ownerUserID int64, shortcut string) (int, bool, error) {
	var id int
	err := tx.QueryRow(ctx, `SELECT shortcut_id FROM quick_replies WHERE owner_user_id = $1 AND lower(shortcut) = lower($2)`, ownerUserID, shortcut).Scan(&id)
	if err == nil {
		return id, false, nil
	}
	if !errors.Is(err, pgx.ErrNoRows) {
		return 0, false, fmt.Errorf("get quick reply shortcut: %w", err)
	}
	var count int
	if err := tx.QueryRow(ctx, `SELECT COUNT(*)::int FROM quick_replies WHERE owner_user_id = $1`, ownerUserID).Scan(&count); err != nil {
		return 0, false, fmt.Errorf("count quick replies: %w", err)
	}
	if count >= domain.MaxQuickReplies {
		return 0, false, domain.ErrQuickRepliesTooMuch
	}
	if err := tx.QueryRow(ctx, `SELECT COALESCE(MAX(shortcut_id), 0)::int + 1 FROM quick_replies WHERE owner_user_id = $1`, ownerUserID).Scan(&id); err != nil {
		return 0, false, fmt.Errorf("allocate quick reply shortcut id: %w", err)
	}
	if _, err := tx.Exec(ctx, `
INSERT INTO quick_replies (owner_user_id, shortcut_id, shortcut, sort_order, created_at, updated_at)
VALUES ($1,$2,$3,$4,now(),now())`, ownerUserID, id, shortcut, count+1); err != nil {
		return 0, false, quickReplyPGErr(err)
	}
	return id, true, nil
}

func (s *PasswordStore) ensureQuickReplyExists(ctx context.Context, ownerUserID int64, shortcutID int) error {
	var id int
	err := s.db.QueryRow(ctx, `SELECT shortcut_id FROM quick_replies WHERE owner_user_id = $1 AND shortcut_id = $2`, ownerUserID, shortcutID).Scan(&id)
	if errors.Is(err, pgx.ErrNoRows) {
		return domain.ErrShortcutInvalid
	}
	if err != nil {
		return fmt.Errorf("get quick reply shortcut: %w", err)
	}
	return nil
}

func (s *PasswordStore) normalizeQuickReplyOrder(ctx context.Context, ownerUserID int64) error {
	return withTx(ctx, s.db, "normalize quick reply order", func(tx pgx.Tx) error {
		replies, err := listQuickRepliesTx(ctx, tx, ownerUserID)
		if err != nil {
			return err
		}
		for i, reply := range replies {
			if _, err := tx.Exec(ctx, `UPDATE quick_replies SET sort_order = $3 WHERE owner_user_id = $1 AND shortcut_id = $2`, ownerUserID, reply.ID, i+1); err != nil {
				return fmt.Errorf("normalize quick reply order: %w", err)
			}
		}
		return nil
	})
}

func scanBusinessChatLink(row interface {
	Scan(dest ...any) error
}) (domain.BusinessChatLink, error) {
	var link domain.BusinessChatLink
	var entitiesJSON string
	if err := row.Scan(&link.Slug, &link.OwnerUserID, &link.Link, &link.Message, &entitiesJSON, &link.Title, &link.Views, &link.CreatedAt, &link.UpdatedAt); err != nil {
		return domain.BusinessChatLink{}, err
	}
	entities, err := decodeMessageEntities(entitiesJSON)
	if err != nil {
		return domain.BusinessChatLink{}, fmt.Errorf("decode business chat link entities: %w", err)
	}
	link.Entities = entities
	return link, nil
}

func scanQuickReplyMessage(ownerUserID int64, shortcutID int, row interface {
	Scan(dest ...any) error
}) (domain.QuickReplyMessage, error) {
	var msg domain.QuickReplyMessage
	var entitiesJSON string
	msg.OwnerUserID = ownerUserID
	msg.ShortcutID = shortcutID
	if err := row.Scan(&msg.ID, &msg.RandomID, &msg.Date, &msg.Message, &entitiesJSON); err != nil {
		return domain.QuickReplyMessage{}, fmt.Errorf("scan quick reply message: %w", err)
	}
	entities, err := decodeMessageEntities(entitiesJSON)
	if err != nil {
		return domain.QuickReplyMessage{}, fmt.Errorf("decode quick reply entities: %w", err)
	}
	msg.Entities = entities
	return msg, nil
}

func scanConnectedBusinessBot(row interface {
	Scan(dest ...any) error
}) (domain.ConnectedBusinessBot, error) {
	var bot domain.ConnectedBusinessBot
	var recipientsJSON, rightsJSON string
	if err := row.Scan(&bot.OwnerUserID, &bot.BotUserID, &recipientsJSON, &rightsJSON, &bot.CreatedAtUnix, &bot.UpdatedAtUnix); err != nil {
		return domain.ConnectedBusinessBot{}, err
	}
	if recipientsJSON != "" && recipientsJSON != "{}" {
		if err := json.Unmarshal([]byte(recipientsJSON), &bot.Recipients); err != nil {
			return domain.ConnectedBusinessBot{}, fmt.Errorf("decode connected business bot recipients: %w", err)
		}
	}
	if rightsJSON != "" && rightsJSON != "{}" {
		if err := json.Unmarshal([]byte(rightsJSON), &bot.Rights); err != nil {
			return domain.ConnectedBusinessBot{}, fmt.Errorf("decode connected business bot rights: %w", err)
		}
	}
	return bot, nil
}

func scanConnectedBusinessBotPeerState(row interface {
	Scan(dest ...any) error
}) (domain.ConnectedBusinessBotPeerState, error) {
	var state domain.ConnectedBusinessBotPeerState
	if err := row.Scan(&state.OwnerUserID, &state.PeerUserID, &state.Paused, &state.Disabled, &state.UpdatedAtUnix); err != nil {
		return domain.ConnectedBusinessBotPeerState{}, err
	}
	return state, nil
}

func encodeNullableJSON[T any](value *T) ([]byte, error) {
	if value == nil {
		return []byte("{}"), nil
	}
	raw, err := json.Marshal(value)
	if err != nil {
		return nil, fmt.Errorf("encode business json: %w", err)
	}
	return raw, nil
}

func decodeNullableJSON[T any](raw string, out **T) error {
	if raw == "" || raw == "{}" {
		*out = nil
		return nil
	}
	var value T
	if err := json.Unmarshal([]byte(raw), &value); err != nil {
		return err
	}
	*out = &value
	return nil
}

func quickReplyByID(replies []domain.QuickReply, id int) domain.QuickReply {
	for _, reply := range replies {
		if reply.ID == id {
			return reply
		}
	}
	return domain.QuickReply{}
}

func postgresQuickReplyListHash(items []domain.QuickReply) int64 {
	h := fnv.New64a()
	for _, item := range items {
		postgresWriteHashInt(h, item.ID)
		postgresWriteHashString(h, item.Shortcut)
		postgresWriteHashInt(h, item.TopMessage)
		postgresWriteHashInt(h, item.Count)
	}
	return int64(h.Sum64() & 0x7fffffffffffffff)
}

func postgresQuickReplyMessagesHash(items []domain.QuickReplyMessage) int64 {
	h := fnv.New64a()
	for _, item := range items {
		postgresWriteHashInt(h, item.ID)
		postgresWriteHashString(h, item.Message)
		postgresWriteHashInt(h, item.Date)
	}
	return int64(h.Sum64() & 0x7fffffffffffffff)
}

func postgresWriteHashInt(h interface{ Write([]byte) (int, error) }, v int) {
	_, _ = h.Write([]byte{byte(v >> 24), byte(v >> 16), byte(v >> 8), byte(v)})
}

func postgresWriteHashString(h interface{ Write([]byte) (int, error) }, v string) {
	_, _ = h.Write([]byte(v))
	_, _ = h.Write([]byte{0})
}

func quickReplyPGErr(err error) error {
	if err == nil {
		return nil
	}
	if strings.Contains(err.Error(), "quick_replies_owner_shortcut_lower_idx") {
		return domain.ErrShortcutOccupied
	}
	return err
}