package store

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

// The three states a proposal can be in. A proposal starts 'proposed' and
// moves once, either way, and never moves again.
const (
	RoutineProposed  = "proposed"
	RoutineAccepted  = "accepted"
	RoutineDismissed = "dismissed"
)

// ProposedRoutine — a detected pattern the system wants to turn into a
// recurring reminder. Status 'proposed' means awaiting human confirmation;
// 'accepted' means the human confirmed and a reminder was created (reminder_id
// set); 'dismissed' means the human declined and we won't re-propose.
type ProposedRoutine struct {
	ID           int64
	Action       string
	Object       string
	IntervalDays float64
	Status       string // proposed | accepted | dismissed
	CreatedTs    time.Time
	ReminderID   *int64 // set when accepted
}

var (
	ErrProposedRoutineNotFound = errors.New("store: proposed routine not found")
	ErrProposedRoutineExists   = errors.New("store: proposed routine already exists for this action+object")
)

// CreateProposedRoutine inserts a new proposed routine. Returns
// ErrProposedRoutineExists if one already exists for this action+object (any
// status) — the pattern detector should only propose once per pair.
//
// action+object is the "same routine" key. It is UNIQUE in the table, so a
// routine the human already dismissed can never come back: the detector will
// keep finding the pattern, and every re-propose is refused here. Maven is not
// a nag.
//
// TODO(vikunja#46): the detector currently only writes here from the voice
// path. Once digestion runs the detector on its own tick, that tick should
// call this too, so a pattern gets noticed even with nobody at the mic.
func (s *Store) CreateProposedRoutine(ctx context.Context, action, object string, intervalDays float64, ts time.Time) (int64, error) {
	res, err := s.db.ExecContext(ctx,
		`INSERT INTO proposed_routines (action, object, interval_days, status, created_ts)
		 VALUES (?,?,?,'proposed',?)
		 ON CONFLICT(action, object) DO NOTHING`,
		action, object, intervalDays, ts.UnixMilli())
	if err != nil {
		return 0, fmt.Errorf("create proposed routine: %w", err)
	}
	n, err := res.RowsAffected()
	if err != nil {
		return 0, fmt.Errorf("create proposed routine: rows affected: %w", err)
	}
	if n == 0 {
		return 0, ErrProposedRoutineExists
	}
	id, err := res.LastInsertId()
	if err != nil {
		return 0, fmt.Errorf("create proposed routine: last insert id: %w", err)
	}
	return id, nil
}

// LookupProposedRoutine returns the proposed routine for action+object, or
// nil (no error) when no row exists.
func (s *Store) LookupProposedRoutine(ctx context.Context, action, object string) (*ProposedRoutine, error) {
	row := s.db.QueryRowContext(ctx, `
		SELECT id, action, object, interval_days, status, created_ts, reminder_id
		  FROM proposed_routines
		 WHERE action = ? AND object = ?`, action, object)
	r, err := scanProposedRoutine(row)
	if errors.Is(err, sql.ErrNoRows) {
		return nil, nil
	}
	if err != nil {
		return nil, err
	}
	return &r, nil
}

// ListProposedRoutines returns the routines still waiting for an answer,
// newest first. This is what the /routines page shows.
func (s *Store) ListProposedRoutines(ctx context.Context) ([]ProposedRoutine, error) {
	return s.ListProposedRoutinesByStatus(ctx, RoutineProposed)
}

// ListProposedRoutinesByStatus returns routines in one status, newest first.
// An empty status returns every row.
//
// TODO(vikunja#46): the tick loop should read the accepted ones from here so a
// routine the human said yes to has a home the loop can see, instead of only
// the reminder row that accepting happened to create.
func (s *Store) ListProposedRoutinesByStatus(ctx context.Context, status string) ([]ProposedRoutine, error) {
	q := `SELECT id, action, object, interval_days, status, created_ts, reminder_id
	        FROM proposed_routines`
	var args []any
	if status != "" {
		q += ` WHERE status = ?`
		args = append(args, status)
	}
	q += ` ORDER BY created_ts DESC, id DESC`

	rows, err := s.db.QueryContext(ctx, q, args...)
	if err != nil {
		return nil, fmt.Errorf("list proposed routines: %w", err)
	}
	defer rows.Close()
	var out []ProposedRoutine
	for rows.Next() {
		r, err := scanProposedRoutine(rows)
		if err != nil {
			return nil, err
		}
		out = append(out, r)
	}
	return out, rows.Err()
}

// Status changes below are an in-place UPDATE, on purpose. Facts are
// append-only (a correction writes a new row and sets voids_id) because a fact
// is a claim about the world and the old claim is still history worth keeping.
// A proposal is not a claim, it is a question with one answer, and the same
// shape already exists for tools (tools.status flips in place). The guard
// `AND status = 'proposed'` makes the move one-way: an answered proposal can
// never be answered again.
//
// AcceptProposedRoutine flips status to 'accepted', links a reminder_id.
// Returns error if not in 'proposed' status.
//
// TODO(vikunja#46): the /routines page calls this through ipc to flip status
// from the authed surface.
func (s *Store) AcceptProposedRoutine(ctx context.Context, id, reminderID int64) error {
	res, err := s.db.ExecContext(ctx,
		`UPDATE proposed_routines SET status = 'accepted', reminder_id = ? WHERE id = ? AND status = 'proposed'`,
		reminderID, id)
	if err != nil {
		return fmt.Errorf("accept proposed routine: %w", err)
	}
	n, _ := res.RowsAffected()
	if n == 0 {
		return fmt.Errorf("%w: id=%d not in 'proposed' status", ErrProposedRoutineNotFound, id)
	}
	return nil
}

// DismissProposedRoutine flips status to 'dismissed'. Idempotent.
func (s *Store) DismissProposedRoutine(ctx context.Context, id int64) error {
	_, err := s.db.ExecContext(ctx,
		`UPDATE proposed_routines SET status = 'dismissed' WHERE id = ? AND status = 'proposed'`,
		id)
	if err != nil {
		return fmt.Errorf("dismiss proposed routine: %w", err)
	}
	return nil
}

// scanProposedRoutine scans a row into ProposedRoutine.
func scanProposedRoutine(sc scanner) (ProposedRoutine, error) {
	var r ProposedRoutine
	var created int64
	var reminderID sql.NullInt64
	if err := sc.Scan(&r.ID, &r.Action, &r.Object, &r.IntervalDays, &r.Status, &created, &reminderID); err != nil {
		return ProposedRoutine{}, err
	}
	r.CreatedTs = time.UnixMilli(created).UTC()
	if reminderID.Valid {
		r.ReminderID = &reminderID.Int64
	}
	return r, nil
}