#include "sqlite_database.h"
#include "sqlite_file_executor.h"
#include "gtest/gtest.h"

// WARNING: Foreign keys are off
// WARNING: Triggers are off

const std::string TEST_DB = "test.db";

// Test fixture for SQLiteDatabase
class SQLiteDatabaseCRUDTest : public ::testing::Test {
protected:
  SQLiteDatabase *db_;

  void SetUp() override {
    db_ = new SQLiteDatabase(TEST_DB);
    SQLiteFileExecutor executor(TEST_DB);
    executor.executeSQLFile("sql/cinema_db_drop_table.sql");
    executor.executeSQLFile("sql/cinema_db_create_table.sql");

    // Not necessarily, since the default setting
    std::string sql;
    FileReaderInterface *reader = &executor;
    reader->read("sql/cinema_db_foreign_key_off.sql", sql);
    db_->executeNonQuery(sql);
  }

  void TearDown() override {
    delete db_;
    remove(TEST_DB.c_str());
  }
};

// INFO: ----- GENERAL -----

// Check that the test fixture is working
class SimpleClass : public ::testing::Test {
protected:
  void SetUp() override {}
  void TearDown() override {}
};
// Simle test
TEST_F(SimpleClass, SimpleTest) { EXPECT_EQ(1, 1); }

// INFO: ----- GENERAL -----

// Test checking if the database is available
TEST_F(SQLiteDatabaseCRUDTest, IsDatabaseAvailable) {
  EXPECT_TRUE(db_->isDatabaseAvailable());
}

// INFO: ----- GENRE -----

// Test adding a genre
TEST_F(SQLiteDatabaseCRUDTest, AddGenre) {
  NewGenre genre{"Action"};
  EXPECT_TRUE(db_->addGenre(genre));

  auto genres = db_->getAllGenres();
  ASSERT_EQ(genres.size(), 1);
  EXPECT_EQ(genres[0].genre_name, "Action");
}

// Test getting a genre by ID
TEST_F(SQLiteDatabaseCRUDTest, GetGenreById) {
  NewGenre genre{"Drama"};
  db_->addGenre(genre);

  Genre retrieved_genre = db_->getGenre(1);
  EXPECT_EQ(retrieved_genre.genre_id, 1);
  EXPECT_EQ(retrieved_genre.genre_name, "Drama");
}

// Test updating a genre
TEST_F(SQLiteDatabaseCRUDTest, UpdateGenre) {
  NewGenre genre{"Drama"};
  db_->addGenre(genre);

  Genre updated_genre = db_->getGenre(1);
  updated_genre.genre_name = "Horror";
  EXPECT_TRUE(db_->updateGenre(updated_genre));

  Genre retrieved_genre = db_->getGenre(1);
  EXPECT_EQ(retrieved_genre.genre_id, 1);
  EXPECT_EQ(retrieved_genre.genre_name, "Horror");
}

// Test removing a genre
TEST_F(SQLiteDatabaseCRUDTest, RemoveGenre) {
  NewGenre genre{"Horror"};
  db_->addGenre(genre);
  EXPECT_TRUE(db_->removeGenre(1));

  auto genres = db_->getAllGenres();
  EXPECT_TRUE(genres.empty());
}

// Test getting all genres
TEST_F(SQLiteDatabaseCRUDTest, GetAllGenres) {
  db_->addGenre({"Comedy"});
  db_->addGenre({"Thriller"});

  auto genres = db_->getAllGenres();
  ASSERT_EQ(genres.size(), 2);
  EXPECT_EQ(genres[0].genre_name, "Comedy");
  EXPECT_EQ(genres[1].genre_name, "Thriller");
}

// INFO: ----- MOVIE -----

// Test adding a movie
TEST_F(SQLiteDatabaseCRUDTest, AddMovie) {
  NewMovie movie{"The Shawshank Redemption", 1, 142};
  EXPECT_TRUE(db_->addMovie(movie));

  auto movies = db_->getAllMovies();
  ASSERT_EQ(movies.size(), 1);
  EXPECT_EQ(movies[0].title, "The Shawshank Redemption");
  EXPECT_EQ(movies[0].genre_id, 1);
  EXPECT_EQ(movies[0].duration, 142);
}

// Test getting a movie by ID
TEST_F(SQLiteDatabaseCRUDTest, GetMovieById) {
  NewMovie movie{"The Godfather", 2, 175};
  db_->addMovie(movie);

  Movie retrieved_movie = db_->getMovie(1);
  EXPECT_EQ(retrieved_movie.movie_id, 1);
  EXPECT_EQ(retrieved_movie.title, "The Godfather");
  EXPECT_EQ(retrieved_movie.genre_id, 2);
  EXPECT_EQ(retrieved_movie.duration, 175);
}

// Test removing a movie
TEST_F(SQLiteDatabaseCRUDTest, RemoveMovie) {
  NewMovie movie{"The Dark Knight", 3, 152};
  db_->addMovie(movie);
  EXPECT_TRUE(db_->removeMovie(1));

  auto movies = db_->getAllMovies();
  EXPECT_TRUE(movies.empty());
}

// Test updating a movie
TEST_F(SQLiteDatabaseCRUDTest, UpdateMovie) {
  NewMovie movie{"The Shawshank Redemption", 1, 142};
  db_->addMovie(movie);

  Movie updated_movie = db_->getMovie(1);
  updated_movie.title = "The Godfather";
  updated_movie.duration = 155;
  EXPECT_TRUE(db_->updateMovie(updated_movie));

  Movie retrieved_movie = db_->getMovie(1);
  EXPECT_EQ(retrieved_movie.movie_id, 1);
  EXPECT_EQ(retrieved_movie.title, "The Godfather");
  EXPECT_EQ(retrieved_movie.genre_id, 1);
  EXPECT_EQ(retrieved_movie.duration, 155);
}

// Test getting all movies
TEST_F(SQLiteDatabaseCRUDTest, GetAllMovies) {
  db_->addMovie({"The Shawshank Redemption", 1, 142});
  db_->addMovie({"The Godfather", 2, 175});

  auto movies = db_->getAllMovies();
  ASSERT_EQ(movies.size(), 2);
  EXPECT_EQ(movies[0].title, "The Shawshank Redemption");
  EXPECT_EQ(movies[0].genre_id, 1);
  EXPECT_EQ(movies[0].duration, 142);
  EXPECT_EQ(movies[1].title, "The Godfather");
  EXPECT_EQ(movies[1].genre_id, 2);
  EXPECT_EQ(movies[1].duration, 175);
}

// INFO: ----- HALL -----

// Test adding a hall
TEST_F(SQLiteDatabaseCRUDTest, AddHall) {
  NewHall hall{"Hall 1", 132};
  EXPECT_TRUE(db_->addHall(hall));

  auto halls = db_->getAllHalls();
  ASSERT_EQ(halls.size(), 1);
  EXPECT_EQ(halls[0].hall_id, 1);
  EXPECT_EQ(halls[0].hall_name, "Hall 1");
  EXPECT_EQ(halls[0].capacity, 132);
}

// Test getting a hall by ID
TEST_F(SQLiteDatabaseCRUDTest, GetHallById) {
  NewHall hall{"Hall 2", 142};
  db_->addHall(hall);

  Hall retrieved_hall = db_->getHall(1);
  EXPECT_EQ(retrieved_hall.hall_id, 1);
  EXPECT_EQ(retrieved_hall.hall_name, "Hall 2");
  EXPECT_EQ(retrieved_hall.capacity, 142);
}

// Test removing a hall
TEST_F(SQLiteDatabaseCRUDTest, RemoveHall) {
  NewHall hall{"Hall 3", 152};
  db_->addHall(hall);
  EXPECT_TRUE(db_->removeHall(1));

  auto halls = db_->getAllHalls();
  EXPECT_TRUE(halls.empty());
}

// Test updating a hall
TEST_F(SQLiteDatabaseCRUDTest, UpdateHall) {
  NewHall hall{"Hall 4", 162};
  db_->addHall(hall);

  Hall updated_hall = db_->getHall(1);
  updated_hall.hall_name = "Hall 5";
  updated_hall.capacity = 172;
  EXPECT_TRUE(db_->updateHall(updated_hall));

  Hall retrieved_hall = db_->getHall(1);
  EXPECT_EQ(retrieved_hall.hall_id, 1);
  EXPECT_EQ(retrieved_hall.hall_name, "Hall 5");
  EXPECT_EQ(retrieved_hall.capacity, 172);
}

// Test getting all halls
TEST_F(SQLiteDatabaseCRUDTest, GetAllHalls) {
  db_->addHall({"Hall 6", 172});
  db_->addHall({"Hall 7", 182});

  auto halls = db_->getAllHalls();
  ASSERT_EQ(halls.size(), 2);
  EXPECT_EQ(halls[0].hall_id, 1);
  EXPECT_EQ(halls[0].hall_name, "Hall 6");
  EXPECT_EQ(halls[0].capacity, 172);
  EXPECT_EQ(halls[1].hall_id, 2);
  EXPECT_EQ(halls[1].hall_name, "Hall 7");
  EXPECT_EQ(halls[1].capacity, 182);
}

// INFO: ----- SESSION -----

// Test adding a session
TEST_F(SQLiteDatabaseCRUDTest, AddSession) {
  NewSession session{1, 1, "2025-01-01 12:00:00", 10};
  EXPECT_TRUE(db_->addSession(session));

  auto sessions = db_->getAllSessions();
  ASSERT_EQ(sessions.size(), 1);
  EXPECT_EQ(sessions[0].movie_id, 1);
  EXPECT_EQ(sessions[0].hall_id, 1);
  EXPECT_EQ(sessions[0].begin_at, "2025-01-01 12:00:00");
  EXPECT_EQ(sessions[0].ticket_price, 10);
}

// Test getting a session by ID
TEST_F(SQLiteDatabaseCRUDTest, GetSessionById) {
  NewSession session{2, 2, "2025-01-01 12:00:00", 10};
  db_->addSession(session);

  Session retrieved_session = db_->getSession(1);
  EXPECT_EQ(retrieved_session.session_id, 1);
  EXPECT_EQ(retrieved_session.movie_id, 2);
  EXPECT_EQ(retrieved_session.hall_id, 2);
  EXPECT_EQ(retrieved_session.begin_at, "2025-01-01 12:00:00");
  EXPECT_EQ(retrieved_session.ticket_price, 10);
}

// Test removing a session
TEST_F(SQLiteDatabaseCRUDTest, RemoveSession) {
  NewSession session{3, 3, "2025-01-01 12:00:00", 10};
  db_->addSession(session);
  EXPECT_TRUE(db_->removeSession(1));

  auto sessions = db_->getAllSessions();
  EXPECT_TRUE(sessions.empty());
}

// Test updating a session
TEST_F(SQLiteDatabaseCRUDTest, UpdateSession) {
  NewSession session{4, 4, "2025-01-01 12:00:00", 10};
  db_->addSession(session);

  Session updated_session = db_->getSession(1);
  updated_session.begin_at = "2025-01-01 13:00:00";
  EXPECT_TRUE(db_->updateSession(updated_session));

  Session retrieved_session = db_->getSession(1);
  EXPECT_EQ(retrieved_session.session_id, 1);
  EXPECT_EQ(retrieved_session.movie_id, 4);
  EXPECT_EQ(retrieved_session.hall_id, 4);
  EXPECT_EQ(retrieved_session.begin_at, "2025-01-01 13:00:00");
  EXPECT_EQ(retrieved_session.ticket_price, 10);
}

// Test getting all sessions
TEST_F(SQLiteDatabaseCRUDTest, GetAllSessions) {
  db_->addSession({5, 5, "2025-01-01 12:00:00", 10});
  db_->addSession({6, 6, "2025-01-01 13:00:00", 10});

  auto sessions = db_->getAllSessions();
  ASSERT_EQ(sessions.size(), 2);
  EXPECT_EQ(sessions[0].movie_id, 5);
  EXPECT_EQ(sessions[0].hall_id, 5);
  EXPECT_EQ(sessions[0].begin_at, "2025-01-01 12:00:00");
  EXPECT_EQ(sessions[0].ticket_price, 10);
  EXPECT_EQ(sessions[1].movie_id, 6);
  EXPECT_EQ(sessions[1].hall_id, 6);
  EXPECT_EQ(sessions[1].begin_at, "2025-01-01 13:00:00");
  EXPECT_EQ(sessions[1].ticket_price, 10);
}

// INFO: ----- TICKET -----

// Test adding a ticket
TEST_F(SQLiteDatabaseCRUDTest, AddTicket) {
  NewTicket ticket{1, 1, "2025-01-01 12:00:00"};
  EXPECT_TRUE(db_->addTicket(ticket));

  auto tickets = db_->getAllTickets();
  ASSERT_EQ(tickets.size(), 1);
  EXPECT_EQ(tickets[0].session_id, 1);
  EXPECT_EQ(tickets[0].seat_number, 1);
  EXPECT_EQ(tickets[0].sold_at, "2025-01-01 12:00:00");
}

// Test getting a ticket by ID
TEST_F(SQLiteDatabaseCRUDTest, GetTicketById) {
  NewTicket ticket{2, 2, "2025-01-01 12:00:00"};
  db_->addTicket(ticket);

  Ticket retrieved_ticket = db_->getTicket(1);
  EXPECT_EQ(retrieved_ticket.ticket_id, 1);
  EXPECT_EQ(retrieved_ticket.session_id, 2);
  EXPECT_EQ(retrieved_ticket.seat_number, 2);
  EXPECT_EQ(retrieved_ticket.sold_at, "2025-01-01 12:00:00");
}

// Test removing a ticket
TEST_F(SQLiteDatabaseCRUDTest, RemoveTicket) {
  NewTicket ticket{3, 3, "2025-01-01 12:00:00"};
  db_->addTicket(ticket);
  EXPECT_TRUE(db_->removeTicket(1));

  auto tickets = db_->getAllTickets();
  EXPECT_TRUE(tickets.empty());
}

// Test updating a ticket
TEST_F(SQLiteDatabaseCRUDTest, UpdateTicket) {
  NewTicket ticket{4, 4, "2025-01-01 12:00:00"};
  db_->addTicket(ticket);

  Ticket updated_ticket = db_->getTicket(1);
  updated_ticket.seat_number = 5;
  EXPECT_TRUE(db_->updateTicket(updated_ticket));

  Ticket retrieved_ticket = db_->getTicket(1);
  EXPECT_EQ(retrieved_ticket.ticket_id, 1);
  EXPECT_EQ(retrieved_ticket.session_id, 4);
  EXPECT_EQ(retrieved_ticket.seat_number, 5);
  EXPECT_EQ(retrieved_ticket.sold_at, "2025-01-01 12:00:00");
}

// Test getting all tickets
TEST_F(SQLiteDatabaseCRUDTest, GetAllTickets) {
  db_->addTicket({5, 5, "2025-01-01 12:00:00"});
  db_->addTicket({6, 6, "2025-01-01 13:00:00"});

  auto tickets = db_->getAllTickets();
  ASSERT_EQ(tickets.size(), 2);
  EXPECT_EQ(tickets[0].session_id, 5);
  EXPECT_EQ(tickets[0].seat_number, 5);
  EXPECT_EQ(tickets[0].sold_at, "2025-01-01 12:00:00");
  EXPECT_EQ(tickets[1].session_id, 6);
  EXPECT_EQ(tickets[1].seat_number, 6);
  EXPECT_EQ(tickets[1].sold_at, "2025-01-01 13:00:00");
}