package repos

import (
	"context"
	"gralias/models"
	"testing"
	"time"

	"github.com/jmoiron/sqlx"
	"github.com/stretchr/testify/assert"
	_ "github.com/mattn/go-sqlite3"
)

func setupTestDB(t *testing.T) (*sqlx.DB, func()) {
	db, err := sqlx.Connect("sqlite3", ":memory:")
	assert.NoError(t, err)

	schema := `
	CREATE TABLE IF NOT EXISTS rooms (
		id TEXT PRIMARY KEY,
		created_at DATETIME,
		creator_name TEXT,
		team_turn TEXT,
		this_turn_limit INTEGER,
		opened_this_turn INTEGER,
		blue_counter INTEGER,
		red_counter INTEGER,
		red_turn BOOLEAN,
		mime_done BOOLEAN,
		is_public BOOLEAN,
		is_running BOOLEAN,
		language TEXT,
		round_time INTEGER,
		is_over BOOLEAN,
		team_won TEXT,
		room_pass TEXT
	);
	`
	_, err = db.Exec(schema)
	assert.NoError(t, err)

	return db, func() {
		db.Close()
	}
}

func TestRoomsRepo_CreateRoom(t *testing.T) {
	db, teardown := setupTestDB(t)
	defer teardown()

	repo := &RepoProvider{DB: db}

	room := &models.Room{
		ID:             "test_room_1",
		CreatedAt:      time.Now(),
		CreatorName:    "test_creator",
		TeamTurn:       "blue",
		ThisTurnLimit:  5,
		OpenedThisTurn: 0,
		BlueCounter:    0,
		RedCounter:     0,
		RedTurn:        false,
		MimeDone:       false,
		IsPublic:       true,
		IsRunning:      false,
		Language:       "en",
		RoundTime:      60,
		IsOver:         false,
		TeamWon:        "",
		RoomPass:       "",
	}

	err := repo.CreateRoom(context.Background(), room)
	assert.NoError(t, err)

	// Verify the room was created
	var retrievedRoom models.Room
	err = db.Get(&retrievedRoom, "SELECT * FROM rooms WHERE id = ?", room.ID)
	assert.NoError(t, err)
	assert.Equal(t, room.ID, retrievedRoom.ID)
	assert.Equal(t, room.CreatorName, retrievedRoom.CreatorName)
}

func TestRoomsRepo_GetRoomByID(t *testing.T) {
	db, teardown := setupTestDB(t)
	defer teardown()

	repo := &RepoProvider{DB: db}

	room := &models.Room{
		ID:             "test_room_2",
		CreatedAt:      time.Now(),
		CreatorName:    "test_creator_2",
		TeamTurn:       "red",
		ThisTurnLimit:  5,
		OpenedThisTurn: 0,
		BlueCounter:    0,
		RedCounter:     0,
		RedTurn:        true,
		MimeDone:       false,
		IsPublic:       true,
		IsRunning:      false,
		Language:       "en",
		RoundTime:      60,
		IsOver:         false,
		TeamWon:        "",
		RoomPass:       "",
	}

	// Insert a room directly into the database for testing GetRoomByID
	_, err := db.Exec(`INSERT INTO rooms (id, created_at, creator_name, team_turn, this_turn_limit, opened_this_turn, blue_counter, red_counter, red_turn, mime_done, is_public, is_running, language, round_time, is_over, team_won, room_pass) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, room.ID, room.CreatedAt, room.CreatorName, room.TeamTurn, room.ThisTurnLimit, room.OpenedThisTurn, room.BlueCounter, room.RedCounter, room.RedTurn, room.MimeDone, room.IsPublic, room.IsRunning, room.Language, room.RoundTime, room.IsOver, room.TeamWon, room.RoomPass)
	assert.NoError(t, err)

	retrievedRoom, err := repo.GetRoomByID(context.Background(), room.ID)
	assert.NoError(t, err)
	assert.NotNil(t, retrievedRoom)
	assert.Equal(t, room.ID, retrievedRoom.ID)
	assert.Equal(t, room.CreatorName, retrievedRoom.CreatorName)
}

func TestRoomsRepo_ListRooms(t *testing.T) {
	db, teardown := setupTestDB(t)
	defer teardown()

	repo := &RepoProvider{DB: db}

	room1 := &models.Room{
		ID:             "list_room_1",
		CreatedAt:      time.Now(),
		CreatorName:    "list_creator_1",
		TeamTurn:       "blue",
		ThisTurnLimit:  5,
		OpenedThisTurn: 0,
		BlueCounter:    0,
		RedCounter:     0,
		RedTurn:        false,
		MimeDone:       false,
		IsPublic:       true,
		IsRunning:      false,
		Language:       "en",
		RoundTime:      60,
		IsOver:         false,
		TeamWon:        "",
		RoomPass:       "",
	}
	room2 := &models.Room{
		ID:             "list_room_2",
		CreatedAt:      time.Now(),
		CreatorName:    "list_creator_2",
		TeamTurn:       "red",
		ThisTurnLimit:  5,
		OpenedThisTurn: 0,
		BlueCounter:    0,
		RedCounter:     0,
		RedTurn:        true,
		MimeDone:       false,
		IsPublic:       true,
		IsRunning:      false,
		Language:       "en",
		RoundTime:      60,
		IsOver:         false,
		TeamWon:        "",
		RoomPass:       "",
	}

	_, err := db.Exec(`INSERT INTO rooms (id, created_at, creator_name, team_turn, this_turn_limit, opened_this_turn, blue_counter, red_counter, red_turn, mime_done, is_public, is_running, language, round_time, is_over, team_won, room_pass) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, room1.ID, room1.CreatedAt, room1.CreatorName, room1.TeamTurn, room1.ThisTurnLimit, room1.OpenedThisTurn, room1.BlueCounter, room1.RedCounter, room1.RedTurn, room1.MimeDone, room1.IsPublic, room1.IsRunning, room1.Language, room1.RoundTime, room1.IsOver, room1.TeamWon, room1.RoomPass)
	assert.NoError(t, err)
	_, err = db.Exec(`INSERT INTO rooms (id, created_at, creator_name, team_turn, this_turn_limit, opened_this_turn, blue_counter, red_counter, red_turn, mime_done, is_public, is_running, language, round_time, is_over, team_won, room_pass) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, room2.ID, room2.CreatedAt, room2.CreatorName, room2.TeamTurn, room2.ThisTurnLimit, room2.OpenedThisTurn, room2.BlueCounter, room2.RedCounter, room2.RedTurn, room2.MimeDone, room2.IsPublic, room2.IsRunning, room2.Language, room2.RoundTime, room2.IsOver, room2.TeamWon, room2.RoomPass)
	assert.NoError(t, err)

	rooms, err := repo.ListRooms(context.Background())
	assert.NoError(t, err)
	assert.Len(t, rooms, 2)
}

func TestRoomsRepo_DeleteRoomByID(t *testing.T) {
	db, teardown := setupTestDB(t)
	defer teardown()

	repo := &RepoProvider{DB: db}

	room := &models.Room{
		ID:             "delete_room_1",
		CreatedAt:      time.Now(),
		CreatorName:    "delete_creator_1",
		TeamTurn:       "blue",
		ThisTurnLimit:  5,
		OpenedThisTurn: 0,
		BlueCounter:    0,
		RedCounter:     0,
		RedTurn:        false,
		MimeDone:       false,
		IsPublic:       true,
		IsRunning:      false,
		Language:       "en",
		RoundTime:      60,
		IsOver:         false,
		TeamWon:        "",
		RoomPass:       "",
	}

	_, err := db.Exec(`INSERT INTO rooms (id, created_at, creator_name, team_turn, this_turn_limit, opened_this_turn, blue_counter, red_counter, red_turn, mime_done, is_public, is_running, language, round_time, is_over, team_won, room_pass) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, room.ID, room.CreatedAt, room.CreatorName, room.TeamTurn, room.ThisTurnLimit, room.OpenedThisTurn, room.BlueCounter, room.RedCounter, room.RedTurn, room.MimeDone, room.IsPublic, room.IsRunning, room.Language, room.RoundTime, room.IsOver, room.TeamWon, room.RoomPass)
	assert.NoError(t, err)

	err = repo.DeleteRoomByID(context.Background(), room.ID)
	assert.NoError(t, err)

	var count int
	err = db.Get(&count, "SELECT COUNT(*) FROM rooms WHERE id = ?", room.ID)
	assert.NoError(t, err)
	assert.Equal(t, 0, count)
}

func TestRoomsRepo_UpdateRoom(t *testing.T) {
	db, teardown := setupTestDB(t)
	defer teardown()

	repo := &RepoProvider{DB: db}

	room := &models.Room{
		ID:             "update_room_1",
		CreatedAt:      time.Now(),
		CreatorName:    "update_creator_1",
		TeamTurn:       "blue",
		ThisTurnLimit:  5,
		OpenedThisTurn: 0,
		BlueCounter:    0,
		RedCounter:     0,
		RedTurn:        false,
		MimeDone:       false,
		IsPublic:       true,
		IsRunning:      false,
		Language:       "en",
		RoundTime:      60,
		IsOver:         false,
		TeamWon:        "",
		RoomPass:       "",
	}

	_, err := db.Exec(`INSERT INTO rooms (id, created_at, creator_name, team_turn, this_turn_limit, opened_this_turn, blue_counter, red_counter, red_turn, mime_done, is_public, is_running, language, round_time, is_over, team_won, room_pass) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, room.ID, room.CreatedAt, room.CreatorName, room.TeamTurn, room.ThisTurnLimit, room.OpenedThisTurn, room.BlueCounter, room.RedCounter, room.RedTurn, room.MimeDone, room.IsPublic, room.IsRunning, room.Language, room.RoundTime, room.IsOver, room.TeamWon, room.RoomPass)
	assert.NoError(t, err)

	room.TeamTurn = "red"
	room.BlueCounter = 10

	err = repo.UpdateRoom(context.Background(), room)
	assert.NoError(t, err)

	var updatedRoom models.Room
	err = db.Get(&updatedRoom, "SELECT * FROM rooms WHERE id = ?", room.ID)
	assert.NoError(t, err)
			assert.Equal(t, models.UserTeam("red"), updatedRoom.TeamTurn)
	assert.Equal(t, uint8(10), updatedRoom.BlueCounter)
}