package store

import (
	"database/sql"
	"path/filepath"
	"testing"
	"time"

	_ "github.com/mattn/go-sqlite3"
	"task-dashboard/internal/models"
)

// setupTestStoreWithTasks creates a test store with tasks table
func setupTestStoreWithTasks(t *testing.T) *Store {
	t.Helper()

	tempDir := t.TempDir()
	dbPath := filepath.Join(tempDir, "test.db")

	db, err := sql.Open("sqlite3", dbPath)
	if err != nil {
		t.Fatalf("Failed to open test database: %v", err)
	}

	db.SetMaxOpenConns(1)

	store := &Store{db: db}

	schema := `
		CREATE TABLE IF NOT EXISTS tasks (
			id TEXT PRIMARY KEY,
			content TEXT NOT NULL,
			description TEXT,
			project_id TEXT,
			project_name TEXT,
			due_date DATETIME,
			priority INTEGER DEFAULT 1,
			completed BOOLEAN DEFAULT FALSE,
			labels TEXT,
			url TEXT,
			created_at DATETIME,
			updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
		);
	`
	if _, err := db.Exec(schema); err != nil {
		t.Fatalf("Failed to create schema: %v", err)
	}

	return store
}

// setupTestStoreWithCards creates a test store with boards and cards tables
func setupTestStoreWithCards(t *testing.T) *Store {
	t.Helper()

	tempDir := t.TempDir()
	dbPath := filepath.Join(tempDir, "test.db")

	db, err := sql.Open("sqlite3", dbPath)
	if err != nil {
		t.Fatalf("Failed to open test database: %v", err)
	}

	db.SetMaxOpenConns(1)

	store := &Store{db: db}

	schema := `
		CREATE TABLE IF NOT EXISTS boards (
			id TEXT PRIMARY KEY,
			name TEXT NOT NULL,
			updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
		);
		CREATE TABLE IF NOT EXISTS cards (
			id TEXT PRIMARY KEY,
			name TEXT NOT NULL,
			board_id TEXT NOT NULL,
			list_id TEXT,
			list_name TEXT,
			due_date DATETIME,
			url TEXT,
			updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
		);
	`
	if _, err := db.Exec(schema); err != nil {
		t.Fatalf("Failed to create schema: %v", err)
	}

	return store
}

// TestDeleteTask verifies that DeleteTask removes a task from the cache
func TestDeleteTask(t *testing.T) {
	store := setupTestStoreWithTasks(t)
	defer store.Close()

	// Save some tasks
	tasks := []models.Task{
		{
			ID:          "task1",
			Content:     "Task 1",
			Description: "Description 1",
			Priority:    1,
			Completed:   false,
			Labels:      []string{},
			CreatedAt:   time.Now(),
		},
		{
			ID:          "task2",
			Content:     "Task 2",
			Description: "Description 2",
			Priority:    2,
			Completed:   false,
			Labels:      []string{},
			CreatedAt:   time.Now(),
		},
		{
			ID:          "task3",
			Content:     "Task 3",
			Description: "Description 3",
			Priority:    3,
			Completed:   false,
			Labels:      []string{},
			CreatedAt:   time.Now(),
		},
	}

	if err := store.SaveTasks(tasks); err != nil {
		t.Fatalf("Failed to save tasks: %v", err)
	}

	// Verify all 3 tasks exist
	result, err := store.GetTasks()
	if err != nil {
		t.Fatalf("Failed to get tasks: %v", err)
	}
	if len(result) != 3 {
		t.Fatalf("Expected 3 tasks, got %d", len(result))
	}

	// Delete task2
	if err := store.DeleteTask("task2"); err != nil {
		t.Fatalf("DeleteTask failed: %v", err)
	}

	// Verify only 2 tasks remain
	result, err = store.GetTasks()
	if err != nil {
		t.Fatalf("Failed to get tasks after delete: %v", err)
	}
	if len(result) != 2 {
		t.Errorf("Expected 2 tasks after delete, got %d", len(result))
	}

	// Verify task2 is gone
	for _, task := range result {
		if task.ID == "task2" {
			t.Errorf("task2 should have been deleted but was found")
		}
	}

	// Verify task1 and task3 still exist
	foundTask1, foundTask3 := false, false
	for _, task := range result {
		if task.ID == "task1" {
			foundTask1 = true
		}
		if task.ID == "task3" {
			foundTask3 = true
		}
	}
	if !foundTask1 {
		t.Error("task1 should still exist")
	}
	if !foundTask3 {
		t.Error("task3 should still exist")
	}
}

// TestDeleteTask_NonExistent verifies that deleting a non-existent task doesn't error
func TestDeleteTask_NonExistent(t *testing.T) {
	store := setupTestStoreWithTasks(t)
	defer store.Close()

	// Delete a task that doesn't exist - should not error
	err := store.DeleteTask("nonexistent")
	if err != nil {
		t.Errorf("DeleteTask on non-existent task should not error, got: %v", err)
	}
}

// TestDeleteCard verifies that DeleteCard removes a card from the cache
func TestDeleteCard(t *testing.T) {
	store := setupTestStoreWithCards(t)
	defer store.Close()

	// First create a board
	_, err := store.db.Exec(`INSERT INTO boards (id, name) VALUES (?, ?)`, "board1", "Test Board")
	if err != nil {
		t.Fatalf("Failed to create board: %v", err)
	}

	// Insert cards directly
	cards := []struct {
		id      string
		name    string
		boardID string
	}{
		{"card1", "Card 1", "board1"},
		{"card2", "Card 2", "board1"},
		{"card3", "Card 3", "board1"},
	}

	for _, card := range cards {
		_, err := store.db.Exec(
			`INSERT INTO cards (id, name, board_id, list_id, list_name) VALUES (?, ?, ?, ?, ?)`,
			card.id, card.name, card.boardID, "list1", "To Do",
		)
		if err != nil {
			t.Fatalf("Failed to insert card: %v", err)
		}
	}

	// Verify all 3 cards exist
	var count int
	err = store.db.QueryRow(`SELECT COUNT(*) FROM cards`).Scan(&count)
	if err != nil {
		t.Fatalf("Failed to count cards: %v", err)
	}
	if count != 3 {
		t.Fatalf("Expected 3 cards, got %d", count)
	}

	// Delete card2
	if err := store.DeleteCard("card2"); err != nil {
		t.Fatalf("DeleteCard failed: %v", err)
	}

	// Verify only 2 cards remain
	err = store.db.QueryRow(`SELECT COUNT(*) FROM cards`).Scan(&count)
	if err != nil {
		t.Fatalf("Failed to count cards after delete: %v", err)
	}
	if count != 2 {
		t.Errorf("Expected 2 cards after delete, got %d", count)
	}

	// Verify card2 is gone
	var exists int
	err = store.db.QueryRow(`SELECT COUNT(*) FROM cards WHERE id = ?`, "card2").Scan(&exists)
	if err != nil {
		t.Fatalf("Failed to check card2: %v", err)
	}
	if exists != 0 {
		t.Errorf("card2 should have been deleted")
	}
}

// TestDeleteCard_NonExistent verifies that deleting a non-existent card doesn't error
func TestDeleteCard_NonExistent(t *testing.T) {
	store := setupTestStoreWithCards(t)
	defer store.Close()

	// Delete a card that doesn't exist - should not error
	err := store.DeleteCard("nonexistent")
	if err != nil {
		t.Errorf("DeleteCard on non-existent card should not error, got: %v", err)
	}
}