package handler_test

import (
	"bytes"
	"context"
	"encoding/json"
	"net/http"
	"net/http/httptest"

	"bugulma/backend/internal/testutils"

	"github.com/gin-gonic/gin"
	. "github.com/onsi/ginkgo/v2"
	. "github.com/onsi/gomega"
	"gorm.io/gorm"

	"bugulma/backend/internal/domain"
	"bugulma/backend/internal/handler"
	"bugulma/backend/internal/repository"
	"bugulma/backend/internal/service"
)

var _ = Describe("SiteHandler", func() {
	var (
		siteHandler      *handler.SiteHandler
		siteService      *service.SiteService
		siteRepo         domain.SiteRepository
		organizationRepo domain.OrganizationRepository
		router           *gin.Engine
		db               *gorm.DB
	)

	BeforeEach(func() {
		gin.SetMode(gin.TestMode)

		// Setup PostgreSQL test database using pgtestdb
		db = testutils.SetupTestDBForGinkgo(GinkgoT())

		siteRepo = repository.NewSiteRepository(db)
		organizationRepo = repository.NewOrganizationRepository(db)
		siteService = service.NewSiteService(siteRepo)
		siteHandler = handler.NewSiteHandler(siteService)

		router = gin.New()
		router.POST("/sites", siteHandler.Create)
		router.GET("/sites/:id", siteHandler.GetByID)
		router.GET("/organizations/:organizationId/sites", siteHandler.GetByOrganization)
		router.GET("/sites/nearby", siteHandler.GetNearby)
		router.GET("/sites", siteHandler.GetAll)
		router.PUT("/sites/:id", siteHandler.Update)
		router.DELETE("/sites/:id", siteHandler.Delete)
	})

	AfterEach(func() {
		// pgtestdb automatically cleans up the database after each test
	})

	Describe("Create", func() {
		It("should create a site", func() {
			// Create organization first (required for foreign key constraint)
			org := &domain.Organization{
				ID:   "org-1",
				Name: "Test Organization",
			}
			Expect(organizationRepo.Create(context.TODO(), org)).To(Succeed())

			reqBody := handler.CreateSiteRequest{
				Name:                "Test Site",
				Latitude:            52.5200,
				Longitude:           13.4050,
				OwnerOrganizationID: "org-1",
			}
			body, _ := json.Marshal(reqBody)
			req, _ := http.NewRequest("POST", "/sites", bytes.NewBuffer(body))
			req.Header.Set("Content-Type", "application/json")
			w := httptest.NewRecorder()

			router.ServeHTTP(w, req)

			Expect(w.Code).To(Equal(http.StatusCreated))

			var resp domain.Site
			err := json.Unmarshal(w.Body.Bytes(), &resp)
			Expect(err).NotTo(HaveOccurred())
			Expect(resp.Name).To(Equal("Test Site"))
			Expect(resp.ID).NotTo(BeEmpty())
		})
	})

	Describe("GetByID", func() {
		It("should return site by ID", func() {
			// Create organization first
			org := &domain.Organization{ID: "org-1", Name: "Org 1"}
			Expect(organizationRepo.Create(context.TODO(), org)).To(Succeed())

			site := &domain.Site{
				ID:                  "site-1",
				Name:                "Existing Site",
				Latitude:            52.52,
				Longitude:           13.405,
				OwnerOrganizationID: "org-1",
			}
			Expect(siteRepo.Create(context.TODO(), site)).To(Succeed())

			req, _ := http.NewRequest("GET", "/sites/site-1", nil)
			w := httptest.NewRecorder()

			router.ServeHTTP(w, req)

			Expect(w.Code).To(Equal(http.StatusOK))

			var resp domain.Site
			err := json.Unmarshal(w.Body.Bytes(), &resp)
			Expect(err).NotTo(HaveOccurred())
			Expect(resp.Name).To(Equal("Existing Site"))
		})
	})

	Describe("GetNearby", func() {
		It("should return nearby sites", func() {
			// Create organization first
			org := &domain.Organization{ID: "org-1", Name: "Org 1"}
			Expect(organizationRepo.Create(context.TODO(), org)).To(Succeed())

			site1 := &domain.Site{
				ID:                  "site-1",
				Latitude:            52.5200,
				Longitude:           13.4050,
				OwnerOrganizationID: "org-1",
			}
			Expect(siteRepo.Create(context.TODO(), site1)).To(Succeed())

			req, _ := http.NewRequest("GET", "/sites/nearby?lat=52.5200&lng=13.4050&radius=10", nil)
			w := httptest.NewRecorder()

			router.ServeHTTP(w, req)

			Expect(w.Code).To(Equal(http.StatusOK))

			var resp []domain.Site
			err := json.Unmarshal(w.Body.Bytes(), &resp)
			Expect(err).NotTo(HaveOccurred())
			Expect(resp).To(HaveLen(1))
		})
	})

	Describe("GetByOrganization", func() {
		It("should return sites for an organization", func() {
			// Create organizations first
			org1 := &domain.Organization{ID: "org-1", Name: "Org 1"}
			org2 := &domain.Organization{ID: "org-2", Name: "Org 2"}
			Expect(organizationRepo.Create(context.TODO(), org1)).To(Succeed())
			Expect(organizationRepo.Create(context.TODO(), org2)).To(Succeed())

			site1 := &domain.Site{
				ID:                  "site-1",
				Name:                "Site 1",
				OwnerOrganizationID: "org-1",
			}
			site2 := &domain.Site{
				ID:                  "site-2",
				Name:                "Site 2",
				OwnerOrganizationID: "org-1",
			}
			site3 := &domain.Site{
				ID:                  "site-3",
				Name:                "Site 3",
				OwnerOrganizationID: "org-2",
			}
			Expect(siteRepo.Create(context.TODO(), site1)).To(Succeed())
			Expect(siteRepo.Create(context.TODO(), site2)).To(Succeed())
			Expect(siteRepo.Create(context.TODO(), site3)).To(Succeed())

			req, _ := http.NewRequest("GET", "/organizations/org-1/sites", nil)
			w := httptest.NewRecorder()

			router.ServeHTTP(w, req)

			Expect(w.Code).To(Equal(http.StatusOK))

			var resp []domain.Site
			err := json.Unmarshal(w.Body.Bytes(), &resp)
			Expect(err).NotTo(HaveOccurred())
			Expect(resp).To(HaveLen(2))
		})
	})

	Describe("GetAll", func() {
		It("should return all sites", func() {
			// Create organization first
			org := &domain.Organization{ID: "org-1", Name: "Org 1"}
			Expect(organizationRepo.Create(context.TODO(), org)).To(Succeed())

			site1 := &domain.Site{
				ID:                  "site-1",
				Name:                "Site 1",
				Latitude:            52.52,
				Longitude:           13.405,
				OwnerOrganizationID: "org-1",
			}
			site2 := &domain.Site{
				ID:                  "site-2",
				Name:                "Site 2",
				Latitude:            52.53,
				Longitude:           13.406,
				OwnerOrganizationID: "org-1",
			}
			Expect(siteRepo.Create(context.TODO(), site1)).To(Succeed())
			Expect(siteRepo.Create(context.TODO(), site2)).To(Succeed())

			req, _ := http.NewRequest("GET", "/sites", nil)
			w := httptest.NewRecorder()

			router.ServeHTTP(w, req)

			Expect(w.Code).To(Equal(http.StatusOK))

			var resp []domain.Site
			err := json.Unmarshal(w.Body.Bytes(), &resp)
			Expect(err).NotTo(HaveOccurred())
			Expect(resp).To(HaveLen(2))
		})
	})

	Describe("Update", func() {
		It("should update a site", func() {
			// Create organization first
			org := &domain.Organization{ID: "org-1", Name: "Org 1"}
			Expect(organizationRepo.Create(context.TODO(), org)).To(Succeed())

			site := &domain.Site{
				ID:                  "site-1",
				Name:                "Original Site",
				Latitude:            52.52,
				Longitude:           13.405,
				OwnerOrganizationID: "org-1",
			}
			Expect(siteRepo.Create(context.TODO(), site)).To(Succeed())

			updateReq := handler.CreateSiteRequest{
				Name:                "Updated Site",
				Latitude:            52.5200,
				Longitude:           13.4050,
				OwnerOrganizationID: "org-1",
			}
			jsonData, _ := json.Marshal(updateReq)

			req, _ := http.NewRequest("PUT", "/sites/site-1", bytes.NewBuffer(jsonData))
			req.Header.Set("Content-Type", "application/json")
			w := httptest.NewRecorder()

			router.ServeHTTP(w, req)

			Expect(w.Code).To(Equal(http.StatusOK))

			// Verify update
			updated, err := siteRepo.GetByID(context.Background(), "site-1")
			Expect(err).NotTo(HaveOccurred())
			Expect(updated.Name).To(Equal("Updated Site"))
		})
	})

	Describe("Delete", func() {
		It("should delete a site", func() {
			// Create organization first
			org := &domain.Organization{ID: "org-1", Name: "Org 1"}
			Expect(organizationRepo.Create(context.TODO(), org)).To(Succeed())

			site := &domain.Site{
				ID:                  "site-1",
				Name:                "Site to Delete",
				Latitude:            52.52,
				Longitude:           13.405,
				OwnerOrganizationID: "org-1",
			}
			Expect(siteRepo.Create(context.TODO(), site)).To(Succeed())

			req, _ := http.NewRequest("DELETE", "/sites/site-1", nil)
			w := httptest.NewRecorder()

			router.ServeHTTP(w, req)

			Expect(w.Code).To(Equal(http.StatusNoContent))

			// Verify it's gone
			_, err := siteRepo.GetByID(context.Background(), "site-1")
			Expect(err).To(HaveOccurred())
		})
	})
})