package database

import (
	"database/sql"
	"fmt"
	"log"

	_ "github.com/marcboeker/go-duckdb/v2"
)

// DB wraps the database connection
type DB struct {
	*sql.DB
}

// NewDB creates a new database connection
func NewDB(dbPath string) (*DB, error) {
	db, err := sql.Open("duckdb", dbPath)
	if err != nil {
		return nil, fmt.Errorf("failed to open database: %w", err)
	}

	if err := db.Ping(); err != nil {
		return nil, fmt.Errorf("failed to ping database: %w", err)
	}

	database := &DB{DB: db}
	if err := database.migrate(); err != nil {
		return nil, fmt.Errorf("failed to migrate database: %w", err)
	}

	return database, nil
}

// migrate runs database migrations
func (db *DB) migrate() error {
	// Create sequences for auto-incrementing primary keys
	sequences := []string{
		`CREATE SEQUENCE IF NOT EXISTS seq_users_id START 1`,
		`CREATE SEQUENCE IF NOT EXISTS seq_jobs_id START 1`,
		`CREATE SEQUENCE IF NOT EXISTS seq_runners_id START 1`,
		`CREATE SEQUENCE IF NOT EXISTS seq_tasks_id START 1`,
		`CREATE SEQUENCE IF NOT EXISTS seq_job_files_id START 1`,
		`CREATE SEQUENCE IF NOT EXISTS seq_manager_secrets_id START 1`,
		`CREATE SEQUENCE IF NOT EXISTS seq_registration_tokens_id START 1`,
		`CREATE SEQUENCE IF NOT EXISTS seq_runner_api_keys_id START 1`,
		`CREATE SEQUENCE IF NOT EXISTS seq_task_logs_id START 1`,
		`CREATE SEQUENCE IF NOT EXISTS seq_task_steps_id START 1`,
	}

	for _, seq := range sequences {
		if _, err := db.Exec(seq); err != nil {
			return fmt.Errorf("failed to create sequence: %w", err)
		}
	}

	schema := `
	CREATE TABLE IF NOT EXISTS users (
		id BIGINT PRIMARY KEY DEFAULT nextval('seq_users_id'),
		email TEXT UNIQUE NOT NULL,
		name TEXT NOT NULL,
		oauth_provider TEXT NOT NULL,
		oauth_id TEXT NOT NULL,
		password_hash TEXT,
		is_admin BOOLEAN NOT NULL DEFAULT false,
		created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
		UNIQUE(oauth_provider, oauth_id)
	);

	CREATE TABLE IF NOT EXISTS runner_api_keys (
		id BIGINT PRIMARY KEY DEFAULT nextval('seq_runner_api_keys_id'),
		key_prefix TEXT NOT NULL, -- First part of API key (e.g., "jk_r1")
		key_hash TEXT NOT NULL, -- SHA256 hash of full API key
		name TEXT NOT NULL, -- Human-readable name
		description TEXT, -- Optional description
		scope TEXT NOT NULL DEFAULT 'user', -- 'manager' or 'user' - manager scope allows all jobs, user scope only allows jobs from key owner
		is_active BOOLEAN NOT NULL DEFAULT true,
		created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
		created_by BIGINT,
		FOREIGN KEY (created_by) REFERENCES users(id),
		UNIQUE(key_prefix)
	);

	CREATE TABLE IF NOT EXISTS jobs (
		id BIGINT PRIMARY KEY DEFAULT nextval('seq_jobs_id'),
		user_id BIGINT NOT NULL,
		job_type TEXT NOT NULL DEFAULT 'render',
		name TEXT NOT NULL,
		status TEXT NOT NULL DEFAULT 'pending',
		progress REAL NOT NULL DEFAULT 0.0,
		frame_start INTEGER,
		frame_end INTEGER,
		output_format TEXT,
		allow_parallel_runners BOOLEAN NOT NULL DEFAULT true,
		timeout_seconds INTEGER DEFAULT 86400,
		blend_metadata TEXT,
		created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
		started_at TIMESTAMP,
		completed_at TIMESTAMP,
		error_message TEXT,
		FOREIGN KEY (user_id) REFERENCES users(id)
	);

	CREATE TABLE IF NOT EXISTS runners (
		id BIGINT PRIMARY KEY DEFAULT nextval('seq_runners_id'),
		name TEXT NOT NULL,
		hostname TEXT NOT NULL,
		ip_address TEXT NOT NULL,
		status TEXT NOT NULL DEFAULT 'offline',
		last_heartbeat TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
		capabilities TEXT,
		api_key_id BIGINT, -- Reference to the API key used for this runner
		api_key_scope TEXT NOT NULL DEFAULT 'user', -- Scope of the API key ('manager' or 'user')
		priority INTEGER NOT NULL DEFAULT 100,
		fingerprint TEXT, -- Hardware fingerprint (NULL for fixed API keys)
		created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
		FOREIGN KEY (api_key_id) REFERENCES runner_api_keys(id)
	);

	CREATE TABLE IF NOT EXISTS tasks (
		id BIGINT PRIMARY KEY DEFAULT nextval('seq_tasks_id'),
		job_id BIGINT NOT NULL,
		runner_id BIGINT,
		frame_start INTEGER NOT NULL,
		frame_end INTEGER NOT NULL,
		status TEXT NOT NULL DEFAULT 'pending',
		output_path TEXT,
		task_type TEXT NOT NULL DEFAULT 'render',
		current_step TEXT,
		retry_count INTEGER NOT NULL DEFAULT 0,
		max_retries INTEGER NOT NULL DEFAULT 3,
		timeout_seconds INTEGER,
		created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
		started_at TIMESTAMP,
		completed_at TIMESTAMP,
		error_message TEXT
	);

	CREATE TABLE IF NOT EXISTS job_files (
		id BIGINT PRIMARY KEY DEFAULT nextval('seq_job_files_id'),
		job_id BIGINT NOT NULL,
		file_type TEXT NOT NULL,
		file_path TEXT NOT NULL,
		file_name TEXT NOT NULL,
		file_size BIGINT NOT NULL,
		created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
	);

	CREATE TABLE IF NOT EXISTS manager_secrets (
		id BIGINT PRIMARY KEY DEFAULT nextval('seq_manager_secrets_id'),
		secret TEXT UNIQUE NOT NULL,
		created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
	);

	CREATE TABLE IF NOT EXISTS task_logs (
		id BIGINT PRIMARY KEY DEFAULT nextval('seq_task_logs_id'),
		task_id BIGINT NOT NULL,
		runner_id BIGINT,
		log_level TEXT NOT NULL,
		message TEXT NOT NULL,
		step_name TEXT,
		created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
	);

	CREATE TABLE IF NOT EXISTS task_steps (
		id BIGINT PRIMARY KEY DEFAULT nextval('seq_task_steps_id'),
		task_id BIGINT NOT NULL,
		step_name TEXT NOT NULL,
		status TEXT NOT NULL DEFAULT 'pending',
		started_at TIMESTAMP,
		completed_at TIMESTAMP,
		duration_ms INTEGER,
		error_message TEXT
	);

	CREATE INDEX IF NOT EXISTS idx_jobs_user_id ON jobs(user_id);
	CREATE INDEX IF NOT EXISTS idx_jobs_status ON jobs(status);
	CREATE INDEX IF NOT EXISTS idx_jobs_user_status_created ON jobs(user_id, status, created_at DESC);
	CREATE INDEX IF NOT EXISTS idx_tasks_job_id ON tasks(job_id);
	CREATE INDEX IF NOT EXISTS idx_tasks_runner_id ON tasks(runner_id);
	CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
	CREATE INDEX IF NOT EXISTS idx_tasks_job_status ON tasks(job_id, status);
	CREATE INDEX IF NOT EXISTS idx_tasks_started_at ON tasks(started_at);
	CREATE INDEX IF NOT EXISTS idx_job_files_job_id ON job_files(job_id);
	CREATE INDEX IF NOT EXISTS idx_runner_api_keys_prefix ON runner_api_keys(key_prefix);
	CREATE INDEX IF NOT EXISTS idx_runner_api_keys_active ON runner_api_keys(is_active);
	CREATE INDEX IF NOT EXISTS idx_runners_api_key_id ON runners(api_key_id);
	CREATE INDEX IF NOT EXISTS idx_task_logs_task_id_created_at ON task_logs(task_id, created_at);
	CREATE INDEX IF NOT EXISTS idx_task_logs_task_id_id ON task_logs(task_id, id DESC);
	CREATE INDEX IF NOT EXISTS idx_task_logs_runner_id ON task_logs(runner_id);
	CREATE INDEX IF NOT EXISTS idx_task_steps_task_id ON task_steps(task_id);
	CREATE INDEX IF NOT EXISTS idx_runners_last_heartbeat ON runners(last_heartbeat);

	CREATE TABLE IF NOT EXISTS settings (
		key TEXT PRIMARY KEY,
		value TEXT NOT NULL,
		updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
	);
	`

	if _, err := db.Exec(schema); err != nil {
		return fmt.Errorf("failed to create schema: %w", err)
	}

	// Database migrations for schema updates
	// NOTE: Migrations are currently disabled since the database is cleared by 'make cleanup-manager'
	// before running. All schema changes have been rolled into the main schema above.
	// When ready to implement proper migrations for production, uncomment and populate this array.
	// TODO: Implement proper database migration system for production use
	migrations := []string{
		// Future migrations will go here when we implement proper migration handling
	}

	for _, migration := range migrations {
		// DuckDB supports IF NOT EXISTS for ALTER TABLE, so we can safely execute
		if _, err := db.Exec(migration); err != nil {
			// Log but don't fail - column might already exist or table might not exist yet
			// This is fine for migrations that run after schema creation
			// For the file_size migration, if it fails (e.g., already BIGINT), that's fine
		}
	}

	// Initialize registration_enabled setting (default: true) if it doesn't exist
	var settingCount int
	err := db.QueryRow("SELECT COUNT(*) FROM settings WHERE key = ?", "registration_enabled").Scan(&settingCount)
	if err == nil && settingCount == 0 {
		_, err = db.Exec("INSERT INTO settings (key, value) VALUES (?, ?)", "registration_enabled", "true")
		if err != nil {
			// Log but don't fail - setting might have been created by another process
			log.Printf("Note: Could not initialize registration_enabled setting: %v", err)
		}
	}

	return nil
}

// Close closes the database connection
func (db *DB) Close() error {
	return db.DB.Close()
}