package sqlite

import (
	"context"
	"database/sql"
	"encoding/json"
	"strings"
	"time"

	"git.gobha.me/xcaliber/chat-switchboard/models"
	"git.gobha.me/xcaliber/chat-switchboard/store"
)

type MessageStore struct{}

func NewMessageStore() *MessageStore { return &MessageStore{} }

func (s *MessageStore) Create(ctx context.Context, m *models.Message) error {
	toolCallsJSON := ToJSON(m.ToolCalls)
	metadataJSON := ToJSON(m.Metadata)
	m.ID = store.NewID()
	m.CreatedAt = time.Now().UTC()
	_, err := DB.ExecContext(ctx, `
		INSERT INTO messages (id, channel_id, role, content, model, tokens_used, tool_calls,
			metadata, parent_id, sibling_index, participant_type, participant_id, created_at)
		VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)`,
		m.ID, m.ChannelID, m.Role, m.Content, m.Model, m.TokensUsed,
		toolCallsJSON, metadataJSON,
		models.NullString(m.ParentID), m.SiblingIndex,
		m.ParticipantType, m.ParticipantID,
		m.CreatedAt.Format(timeFmt),
	)
	return err
}

func (s *MessageStore) GetByID(ctx context.Context, id string) (*models.Message, error) {
	var m models.Message
	var parentID sql.NullString
	var toolCallsJSON, metadataJSON []byte
	var deletedAt *time.Time
	err := DB.QueryRowContext(ctx, `
		SELECT id, channel_id, role, content, model, tokens_used, tool_calls, metadata,
			parent_id, sibling_index, participant_type, participant_id, deleted_at, created_at
		FROM messages WHERE id = ?`, id).Scan(
		&m.ID, &m.ChannelID, &m.Role, &m.Content, &m.Model, &m.TokensUsed,
		&toolCallsJSON, &metadataJSON,
		&parentID, &m.SiblingIndex, &m.ParticipantType, &m.ParticipantID,
		stN(&deletedAt), st(&m.CreatedAt),
	)
	if err != nil {
		return nil, err
	}
	m.ParentID = NullableStringPtr(parentID)
	json.Unmarshal(toolCallsJSON, &m.ToolCalls)
	json.Unmarshal(metadataJSON, &m.Metadata)
	m.DeletedAt = deletedAt
	return &m, nil
}

func (s *MessageStore) Update(ctx context.Context, id string, fields map[string]interface{}) error {
	b := NewUpdate("messages")
	for k, v := range fields {
		if k == "tool_calls" || k == "metadata" {
			b.SetJSON(k, v)
		} else {
			b.Set(k, v)
		}
	}
	if !b.HasSets() {
		return nil
	}
	b.Where("id", id)
	_, err := b.Exec(DB)
	return err
}

func (s *MessageStore) Delete(ctx context.Context, id string) error {
	now := time.Now()
	_, err := DB.ExecContext(ctx, "UPDATE messages SET deleted_at = ? WHERE id = ?", now, id)
	return err
}

func (s *MessageStore) ListForChannel(ctx context.Context, channelID string, opts store.ListOptions) ([]models.Message, error) {
	b := NewSelect(
		"id, channel_id, role, content, model, tokens_used, tool_calls, metadata, parent_id, sibling_index, participant_type, participant_id, deleted_at, created_at",
		"messages",
	).Where("channel_id = ?", channelID).WhereRaw("deleted_at IS NULL")
	if opts.Sort == "" {
		b.OrderBy("created_at", "ASC")
	}
	b.Paginate(opts)

	q, args := b.Build()
	rows, err := DB.QueryContext(ctx, q, args...)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	return scanMessages(rows)
}

func (s *MessageStore) GetChildren(ctx context.Context, parentID string) ([]models.Message, error) {
	rows, err := DB.QueryContext(ctx, `
		SELECT id, channel_id, role, content, model, tokens_used, tool_calls, metadata,
			parent_id, sibling_index, participant_type, participant_id, deleted_at, created_at
		FROM messages WHERE parent_id = ? AND deleted_at IS NULL
		ORDER BY sibling_index`, parentID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	return scanMessages(rows)
}

func (s *MessageStore) GetSiblings(ctx context.Context, messageID string) ([]models.Message, error) {
	rows, err := DB.QueryContext(ctx, `
		SELECT id, channel_id, role, content, model, tokens_used, tool_calls, metadata,
			parent_id, sibling_index, participant_type, participant_id, deleted_at, created_at
		FROM messages
		WHERE parent_id = (SELECT parent_id FROM messages WHERE id = ?)
			AND deleted_at IS NULL
		ORDER BY sibling_index`, messageID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	return scanMessages(rows)
}

func (s *MessageStore) GetPathToRoot(ctx context.Context, messageID string) ([]models.Message, error) {
	rows, err := DB.QueryContext(ctx, `
		WITH RECURSIVE path AS (
			SELECT id, channel_id, role, content, model, tokens_used, tool_calls, metadata,
				parent_id, sibling_index, participant_type, participant_id, deleted_at, created_at
			FROM messages WHERE id = ?
			UNION ALL
			SELECT m.id, m.channel_id, m.role, m.content, m.model, m.tokens_used, m.tool_calls, m.metadata,
				m.parent_id, m.sibling_index, m.participant_type, m.participant_id, m.deleted_at, m.created_at
			FROM messages m JOIN path p ON m.id = p.parent_id
		)
		SELECT id, channel_id, role, content, model, tokens_used, tool_calls, metadata,
			parent_id, sibling_index, participant_type, participant_id, deleted_at, created_at
		FROM path ORDER BY created_at ASC`, messageID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	return scanMessages(rows)
}

func (s *MessageStore) GetNextSiblingIndex(ctx context.Context, parentID string) (int, error) {
	var maxIdx sql.NullInt64
	err := DB.QueryRowContext(ctx,
		"SELECT MAX(sibling_index) FROM messages WHERE parent_id = ? AND deleted_at IS NULL",
		parentID).Scan(&maxIdx)
	if err != nil || !maxIdx.Valid {
		return 0, err
	}
	return int(maxIdx.Int64) + 1, nil
}

func (s *MessageStore) CountForChannel(ctx context.Context, channelID string) (int, error) {
	var count int
	err := DB.QueryRowContext(ctx,
		"SELECT COUNT(*) FROM messages WHERE channel_id = ? AND deleted_at IS NULL",
		channelID).Scan(&count)
	return count, err
}

func scanMessages(rows *sql.Rows) ([]models.Message, error) {
	var result []models.Message
	for rows.Next() {
		var m models.Message
		var parentID sql.NullString
		var toolCallsJSON, metadataJSON []byte
		var deletedAt *time.Time
		err := rows.Scan(
			&m.ID, &m.ChannelID, &m.Role, &m.Content, &m.Model, &m.TokensUsed,
			&toolCallsJSON, &metadataJSON,
			&parentID, &m.SiblingIndex, &m.ParticipantType, &m.ParticipantID,
			stN(&deletedAt), st(&m.CreatedAt),
		)
		if err != nil {
			return nil, err
		}
		m.ParentID = NullableStringPtr(parentID)
		json.Unmarshal(toolCallsJSON, &m.ToolCalls)
		json.Unmarshal(metadataJSON, &m.Metadata)
		m.DeletedAt = deletedAt
		result = append(result, m)
	}
	return result, rows.Err()
}

// ── CS2 additions (v0.29.0) ─────────────────────────────────────────────

func (s *MessageStore) CountAll(ctx context.Context) (int, error) {
	var count int
	err := DB.QueryRowContext(ctx, "SELECT COUNT(*) FROM messages").Scan(&count)
	return count, err
}

// ── CS5c additions (v0.29.0) ─────────────────────────────────────────────

func (s *MessageStore) SearchInChannel(ctx context.Context, channelID, query, roleFilter string, limit int) ([]store.ChannelSearchResult, error) {
	words := strings.Fields(query)
	if len(words) == 0 {
		return []store.ChannelSearchResult{}, nil
	}

	q := `SELECT m.id, m.role, SUBSTR(m.content, 1, 300), m.created_at
	      FROM messages m
	      WHERE m.channel_id = ?
	        AND m.deleted_at IS NULL
	        AND m.role IN ('user', 'assistant')`
	args := []interface{}{channelID}

	if roleFilter == "user" || roleFilter == "assistant" {
		q += " AND m.role = ?"
		args = append(args, roleFilter)
	}

	for _, w := range words {
		q += " AND m.content LIKE ?"
		args = append(args, "%"+w+"%")
	}

	q += " ORDER BY m.created_at DESC LIMIT ?"
	args = append(args, limit)

	rows, err := DB.QueryContext(ctx, q, args...)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	results := make([]store.ChannelSearchResult, 0)
	for rows.Next() {
		var r store.ChannelSearchResult
		if err := rows.Scan(&r.MessageID, &r.Role, &r.Excerpt, st(&r.Timestamp)); err != nil {
			continue
		}
		r.Rank = 1.0 // no ranking on SQLite
		results = append(results, r)
	}
	return results, rows.Err()
}

// ── CS7a additions (v0.29.0) ────────────────────────────────────────────

func (s *MessageStore) ListWithSenderInfo(ctx context.Context, channelID string, limit, offset int) ([]store.MessageWithSender, int, error) {
	var total int
	err := DB.QueryRowContext(ctx,
		`SELECT COUNT(*) FROM messages WHERE channel_id = ? AND deleted_at IS NULL`,
		channelID).Scan(&total)
	if err != nil {
		return nil, 0, err
	}

	rows, err := DB.QueryContext(ctx, `
		SELECT m.id, m.channel_id, m.role, m.content, m.model, m.tokens_used, m.parent_id,
		       m.sibling_index, m.participant_type, m.participant_id,
		       CASE WHEN m.participant_type = 'user' THEN COALESCE(u.display_name, u.username)
		            WHEN m.participant_type = 'persona' THEN p.name
		            ELSE NULL END AS sender_name,
		       CASE WHEN m.participant_type = 'user' THEN u.avatar_url
		            WHEN m.participant_type = 'persona' THEN p.avatar
		            ELSE NULL END AS sender_avatar,
		       m.created_at
		FROM messages m
		LEFT JOIN users u ON m.participant_type = 'user' AND m.participant_id = u.id
		LEFT JOIN personas p ON m.participant_type = 'persona' AND m.participant_id = p.id
		WHERE m.channel_id = ? AND m.deleted_at IS NULL
		ORDER BY m.created_at ASC
		LIMIT ? OFFSET ?
	`, channelID, limit, offset)
	if err != nil {
		return nil, 0, err
	}
	defer rows.Close()

	results := make([]store.MessageWithSender, 0)
	for rows.Next() {
		var m store.MessageWithSender
		if err := rows.Scan(
			&m.ID, &m.ChannelID, &m.Role, &m.Content,
			&m.Model, &m.TokensUsed, &m.ParentID,
			&m.SiblingIndex, &m.ParticipantType, &m.ParticipantID,
			&m.SenderName, &m.SenderAvatar,
			&m.CreatedAt,
		); err != nil {
			return nil, total, err
		}
		results = append(results, m)
	}
	return results, total, rows.Err()
}

func (s *MessageStore) GetParentAndRole(ctx context.Context, messageID, channelID string) (*string, string, error) {
	var parentID sql.NullString
	var role string
	err := DB.QueryRowContext(ctx, `
		SELECT parent_id, role FROM messages
		WHERE id = ? AND channel_id = ? AND deleted_at IS NULL
	`, messageID, channelID).Scan(&parentID, &role)
	if err != nil {
		return nil, "", err
	}
	return NullableStringPtr(parentID), role, nil
}