// cmd/main.go
package main

import (
	"database/sql"
	"fmt"
	"log"
	"net/http"
	"time"

	"upupa_dataist_ir/internal/api"
	"upupa_dataist_ir/internal/store"
	"upupa_dataist_ir/pkg/models"

	"github.com/go-chi/chi/v5"
)

const DB_FILE = "upupa_dataist.db"

func main() {
	log.Println("Initializing database...")

	dbStore, err := store.NewSQLiteStore(DB_FILE)
	if err != nil {
		log.Fatalf("Failed to connect to database: %v", err)
	}
	log.Println("Database connection successful.")

	if err := dbStore.InitSchema(); err != nil {
		log.Fatalf("Failed to initialize database schema: %v", err)
	}
	log.Println("Database schema initialized.")

	if err := createSystemCollections(dbStore); err != nil {
		log.Fatalf("Failed to create system collections: %v", err)
	}
	log.Println("System collections created successfully.")

	if err := createProductCollection(dbStore, dbStore); err != nil {
		log.Fatalf("Failed to create product records: %v", err)
	}
	log.Println("Product collection and test record created successfully.")

	apiService := api.NewAPI(dbStore, dbStore)
	router := chi.NewRouter()

	router.Get("/api/health", apiService.HealthCheck)

	router.Get("/api/collections/{name}/records/{id}", apiService.GetRecordByIDHandler)
	router.Put("/api/collections/{name}/records/{id}", apiService.UpdateRecordHandler)
	router.Delete("/api/collections/{name}/records/{id}", apiService.DeleteRecordHandler)

	router.Get("/api/collections/{name}/records", apiService.GetAllRecordsHandler)
	router.Post("/api/collections/{name}/records", apiService.CreateRecordHandler)

	httpServer := &http.Server{
		Addr:         ":8081",
		Handler:      router,
		ReadTimeout:  5 * time.Second,
		WriteTimeout: 10 * time.Second,
		IdleTimeout:  120 * time.Second,
	}

	log.Println("Server initialized. Starting API server on http://localhost:8081")
	if err := httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
		log.Fatalf("Could not start server: %v", err)
	}

}

func createSystemCollections(repo store.CollectionRepository) error {
	usersCollectionID := "r6k495b5i2n2x8k"

	_, err := repo.GetByName("users")

	if err == sql.ErrNoRows {

		userCollection := models.Collection{
			ID:     usersCollectionID,
			Name:   "users",
			System: true,
		}

		log.Println("Creating system collection 'users'...")
		if _, err := repo.CreateCollection(userCollection); err != nil {
			return err
		}

	} else if err != nil {
		return err
	}

	return nil
}

func createProductCollection(colRepo store.CollectionRepository, recRepo store.RecordRepository) error {
	productCollectionID := "t1t8t8p8c8c6v5s"
	productID := "a4g7m2c9s3f1h0j"

	_, err := colRepo.GetByName("products")

	if err == sql.ErrNoRows {

		productCollection := models.Collection{
			ID:     productCollectionID,
			Name:   "products",
			System: false,
		}

		log.Println("Creating collection 'products'...")
		if _, err := colRepo.CreateCollection(productCollection); err != nil {
			return err
		}

	} else if err != nil {
		return err
	}

	productData := map[string]interface{}{
		"name":        "تست",
		"price":       49.99,
		"stock":       100,
		"releaseDate": time.Now().Format("2006-01-02"),
	}

	newRecord := models.Record{
		ID:           productID,
		CollectionID: productCollectionID,
		Data:         productData,
	}

	log.Println("Adding test product record...")

	if _, err := recRepo.CreateRecord(newRecord); err != nil {

		if err.Error() == "UNIQUE constraint failed: records.id" ||
			err.Error() == "UNIQUE constraint failed: records.collection_id, records.id" {
			log.Println("Test record already exists, skipping creation.")
			return nil
		}
		return fmt.Errorf("failed to create record: %w", err)
	}

	return nil
}