package http

import (
	"database/sql"
	"encoding/json"
	"github.com/DATA-DOG/go-sqlmock"
	"github.com/gorilla/mux"
	"gopkg.in/guregu/null.v4"
	db "infra-dashboard/Database"
	"log"
	"net/http"
	"net/http/httptest"
	"reflect"
	"regexp"
	"testing"
)

func TestGetOS(t *testing.T) {
	// Créer une connexion à la base de données simulée
	dbConn, mock, err := sqlmock.New()
	if err != nil {
		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
	}
	defer dbConn.Close()

	// Simuler la réponse de la base de données
	mockOSList := []db.OS{
		{ID: 1, Distribution: null.StringFrom("Ubuntu"), Version: null.StringFrom("22.04"), EndOfSupport: null.StringFrom("2026-04-01")},
		{ID: 2, Distribution: null.StringFrom("Debian"), Version: null.StringFrom("12"), EndOfSupport: null.StringFrom("2028-04-01")},
	}

	rows := sqlmock.NewRows([]string{"id", "distribution", "version", "end_of_support"}).
		AddRow(1, "Ubuntu", "22.04", "2026-04-01").
		AddRow(2, "Debian", "12", "2028-04-01")

	mock.ExpectQuery(regexp.QuoteMeta("SELECT * FROM dashboard_os")).WillReturnRows(rows)

	// Remplacer la fonction GetDatabaseConnection par une version mockée
	originalGetDatabaseConnection := db.GetDatabaseConnection
	db.GetDatabaseConnection = func() *sql.DB {
		return dbConn
	}
	defer func() { db.GetDatabaseConnection = originalGetDatabaseConnection }()

	// Créer une requête HTTP
	req, err := http.NewRequest("GET", "/os", nil)
	if err != nil {
		t.Fatal(err)
	}

	// Créer un ResponseRecorder pour enregistrer la réponse
	rr := httptest.NewRecorder()
	handler := http.HandlerFunc(GetOS)

	// Appeler la fonction GetOS
	handler.ServeHTTP(rr, req)

	// Vérifier le statut de la réponse
	if status := rr.Code; status != http.StatusOK {
		t.Errorf("handler returned wrong status code: got %v want %v",
			status, http.StatusOK)
	}

	// Vérifier le type de contenu de la réponse
	expectedContentType := "application/json"
	if ct := rr.Header().Get("Content-Type"); ct != expectedContentType {
		t.Errorf("handler returned wrong content type: got %v want %v",
			ct, expectedContentType)
	}

	// Vérifier le corps de la réponse
	var responseOSList []db.OS
	err = json.NewDecoder(rr.Body).Decode(&responseOSList)
	if err != nil {
		t.Fatal(err)
	}

	if !reflect.DeepEqual(responseOSList, mockOSList) {
		t.Errorf("handler returned unexpected body: got %v want %v",
			responseOSList, mockOSList)
	}

	// Vérifier que toutes les attentes ont été satisfaites
	if err := mock.ExpectationsWereMet(); err != nil {
		t.Errorf("there were unfulfilled expectations: %s", err)
	}
}

func TestGetOSbyID(t *testing.T) {
	// Créer une connexion à la base de données simulée
	dbConn, mock, err := sqlmock.New()
	if err != nil {
		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
	}
	defer dbConn.Close()

	// Simuler la réponse de la base de données
	mockOS := db.OS{
		ID: 1, Distribution: null.StringFrom("Ubuntu"), Version: null.StringFrom("22.04"), EndOfSupport: null.StringFrom("2026-04-01"),
	}

	rows := sqlmock.NewRows([]string{"id", "distribution", "version", "end_of_support"}).
		AddRow(1, "Ubuntu", "22.04", "2026-04-01")

	mock.ExpectQuery(regexp.QuoteMeta("SELECT * FROM dashboard_os where id = ?")).WithArgs(sqlmock.AnyArg()).WillReturnRows(rows)

	// Remplacer la fonction GetDatabaseConnection par une version mockée
	originalGetDatabaseConnection := db.GetDatabaseConnection
	db.GetDatabaseConnection = func() *sql.DB {
		return dbConn
	}
	defer func() { db.GetDatabaseConnection = originalGetDatabaseConnection }()

	// Créer une requête HTTP
	req, err := http.NewRequest("GET", "/os/1", nil)
	if err != nil {
		t.Fatal(err)
	}

	// Ajouter les paramètres de la route
	req = mux.SetURLVars(req, map[string]string{"id": "1"})

	// Créer un ResponseRecorder pour enregistrer la réponse
	rr := httptest.NewRecorder()
	handler := http.HandlerFunc(GetOSbyID)

	// Appeler la fonction GetOS
	handler.ServeHTTP(rr, req)

	// Vérifier le statut de la réponse
	if status := rr.Code; status != http.StatusOK {
		t.Errorf("handler returned wrong status code: got %v want %v",
			status, http.StatusOK)
	}

	// Vérifier le type de contenu de la réponse
	expectedContentType := "application/json"
	if ct := rr.Header().Get("Content-Type"); ct != expectedContentType {
		t.Errorf("handler returned wrong content type: got %v want %v",
			ct, expectedContentType)
	}

	// Vérifier le corps de la réponse
	var responseOS db.OS
	err = json.NewDecoder(rr.Body).Decode(&responseOS)
	if err != nil {
		t.Fatal("Error decoding json request", err)
	}

	if !reflect.DeepEqual(responseOS, mockOS) {
		t.Errorf("handler returned unexpected body: got %v want %v",
			responseOS, mockOS)
	}

	// Vérifier que toutes les attentes ont été satisfaites
	if err := mock.ExpectationsWereMet(); err != nil {
		t.Errorf("there were unfulfilled expectations: %s", err)
	}
}

func TestGetDistributionList(t *testing.T) {
	// Créer une connexion à la base de données simulée
	dbConn, mock, err := sqlmock.New()
	if err != nil {
		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
	}
	defer dbConn.Close()

	// Simuler la réponse de la base de données
	mockDistributionList := []null.String{}
	mockDistributionList = append(mockDistributionList, null.StringFrom("Ubuntu"))
	mockDistributionList = append(mockDistributionList, null.StringFrom("Debian"))

	rows := sqlmock.NewRows([]string{"distribution"}).
		AddRow("Ubuntu").
		AddRow("Debian")

	mock.ExpectQuery(regexp.QuoteMeta("SELECT DISTINCT distribution FROM dashboard_os")).WillReturnRows(rows)

	// Remplacer la fonction GetDatabaseConnection par une version mockée
	originalGetDatabaseConnection := db.GetDatabaseConnection
	db.GetDatabaseConnection = func() *sql.DB {
		return dbConn
	}
	defer func() { db.GetDatabaseConnection = originalGetDatabaseConnection }()

	// Créer une requête HTTP
	req, err := http.NewRequest("GET", "/os/distribution", nil)
	if err != nil {
		t.Fatal(err)
	}

	// Créer un ResponseRecorder pour enregistrer la réponse
	rr := httptest.NewRecorder()
	handler := http.HandlerFunc(GetDistributionList)

	// Appeler la fonction GetOS
	handler.ServeHTTP(rr, req)

	// Vérifier le statut de la réponse
	if status := rr.Code; status != http.StatusOK {
		t.Errorf("handler returned wrong status code: got %v want %v",
			status, http.StatusOK)
	}

	// Vérifier le type de contenu de la réponse
	expectedContentType := "application/json"
	if ct := rr.Header().Get("Content-Type"); ct != expectedContentType {
		t.Errorf("handler returned wrong content type: got %v want %v",
			ct, expectedContentType)
	}

	// Vérifier le corps de la réponse
	var responseOSList []null.String
	err = json.NewDecoder(rr.Body).Decode(&responseOSList)
	log.Println(responseOSList)
	if err != nil {
		t.Fatal(err)
	}

	if !reflect.DeepEqual(responseOSList, mockDistributionList) {
		t.Errorf("handler returned unexpected body: got %v want %v",
			responseOSList, mockDistributionList)
	}

	// Vérifier que toutes les attentes ont été satisfaites
	if err := mock.ExpectationsWereMet(); err != nil {
		t.Errorf("there were unfulfilled expectations: %s", err)
	}
}