website/internal/handlers/lottery/syndicate/syndicate.go

package handlers

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

	templateHandlers "synlotto-website/internal/handlers/template"
	securityHelpers "synlotto-website/internal/helpers/security"
	templateHelpers "synlotto-website/internal/helpers/template"

	"synlotto-website/internal/helpers"
	"synlotto-website/internal/models"
	"synlotto-website/internal/storage"
)

func CreateSyndicateHandler(db *sql.DB) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		switch r.Method {
		case http.MethodGet:
			data := templateHandlers.BuildTemplateData(db, w, r)
			context := templateHelpers.TemplateContext(w, r, data)
			tmpl := templateHelpers.LoadTemplateFiles("create-syndicate.html", "templates/syndicate/create.html")
			tmpl.ExecuteTemplate(w, "layout", context)

		case http.MethodPost:
			name := r.FormValue("name")
			description := r.FormValue("description")

			userId, ok := securityHelpers.GetCurrentUserID(r)
			if !ok || name == "" {
				templateHelpers.SetFlash(w, r, "Invalid data submitted")
				http.Redirect(w, r, "/syndicate/create", http.StatusSeeOther)
				return
			}

			_, err := storage.CreateSyndicate(db, userId, name, description)
			if err != nil {
				log.Printf("❌ CreateSyndicate failed: %v", err)
				templateHelpers.SetFlash(w, r, "Failed to create syndicate")
			} else {
				templateHelpers.SetFlash(w, r, "Syndicate created successfully")
			}

			http.Redirect(w, r, "/syndicate", http.StatusSeeOther)
		default:
			templateHelpers.RenderError(w, r, http.StatusMethodNotAllowed)
		}
	}
}

func ListSyndicatesHandler(db *sql.DB) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		userID, ok := securityHelpers.GetCurrentUserID(r)
		if !ok {
			templateHelpers.RenderError(w, r, 403) // ToDo need to make this use the handler so i dont need to define errors.
			return
		}

		managed := storage.GetSyndicatesByOwner(db, userID)
		member := storage.GetSyndicatesByMember(db, userID)

		managedMap := make(map[int]bool)
		for _, s := range managed {
			managedMap[s.ID] = true
		}

		var filteredJoined []models.Syndicate
		for _, s := range member {
			if !managedMap[s.ID] {
				filteredJoined = append(filteredJoined, s)
			}
		}

		data := templateHandlers.BuildTemplateData(db, w, r)
		context := templateHelpers.TemplateContext(w, r, data)
		context["ManagedSyndicates"] = managed
		context["JoinedSyndicates"] = filteredJoined

		tmpl := templateHelpers.LoadTemplateFiles("syndicates.html", "templates/syndicate/index.html")
		tmpl.ExecuteTemplate(w, "layout", context)
	}
}

func ViewSyndicateHandler(db *sql.DB) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		userID, ok := securityHelpers.GetCurrentUserID(r)
		if !ok {
			templateHelpers.RenderError(w, r, 403)
			return
		}

		syndicateID := helpers.Atoi(r.URL.Query().Get("id"))
		syndicate, err := storage.GetSyndicateByID(db, syndicateID)
		if err != nil || syndicate == nil {
			templateHelpers.RenderError(w, r, 404)
			return
		}

		isManager := userID == syndicate.OwnerID
		isMember := storage.IsSyndicateMember(db, syndicateID, userID)

		if !isManager && !isMember {
			templateHelpers.RenderError(w, r, 403)
			return
		}

		members := storage.GetSyndicateMembers(db, syndicateID)

		data := templateHandlers.BuildTemplateData(db, w, r)
		context := templateHelpers.TemplateContext(w, r, data)
		context["Syndicate"] = syndicate
		context["Members"] = members
		context["IsManager"] = isManager

		tmpl := templateHelpers.LoadTemplateFiles("syndicate-view.html", "templates/syndicate/view.html")
		tmpl.ExecuteTemplate(w, "layout", context)
	}
}

func SyndicateLogTicketHandler(db *sql.DB) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		userID, ok := securityHelpers.GetCurrentUserID(r)
		if !ok {
			templateHelpers.RenderError(w, r, 403)
			return
		}

		syndicateId := helpers.Atoi(r.URL.Query().Get("id"))
		syndicate, err := storage.GetSyndicateByID(db, syndicateId)
		if err != nil || syndicate.OwnerID != userID {
			templateHelpers.RenderError(w, r, 403)
			return
		}

		switch r.Method {
		case http.MethodGet:
			data := templateHandlers.BuildTemplateData(db, w, r)
			context := templateHelpers.TemplateContext(w, r, data)
			context["Syndicate"] = syndicate

			tmpl := templateHelpers.LoadTemplateFiles("syndicate-log-ticket.html", "templates/syndicate/log_ticket.html")
			tmpl.ExecuteTemplate(w, "layout", context)

		case http.MethodPost:
			gameType := r.FormValue("game_type")
			drawDate := r.FormValue("draw_date")
			method := r.FormValue("purchase_method")

			err := storage.InsertTicket(db, models.Ticket{
				UserId:         userID,
				GameType:       gameType,
				DrawDate:       drawDate,
				PurchaseMethod: method,
				SyndicateId:    &syndicateId,
				// ToDo image path
			})

			if err != nil {
				templateHelpers.SetFlash(w, r, "Failed to add ticket.")
			} else {
				templateHelpers.SetFlash(w, r, "Ticket added for syndicate.")
			}

			http.Redirect(w, r, fmt.Sprintf("/syndicate/view?id=%d", syndicateId), http.StatusSeeOther)

		default:
			templateHelpers.RenderError(w, r, 405)
		}
	}
}

func SyndicateTicketsHandler(db *sql.DB) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		userID, ok := securityHelpers.GetCurrentUserID(r)
		if !ok {
			templateHelpers.RenderError(w, r, 403)
			return
		}

		syndicateID := helpers.Atoi(r.URL.Query().Get("id"))
		if syndicateID == 0 {
			templateHelpers.RenderError(w, r, 400)
			return
		}

		if !storage.IsSyndicateMember(db, syndicateID, userID) {
			templateHelpers.RenderError(w, r, 403)
			return
		}

		tickets := storage.GetSyndicateTickets(db, syndicateID)

		data := templateHandlers.BuildTemplateData(db, w, r)
		context := templateHelpers.TemplateContext(w, r, data)
		context["SyndicateID"] = syndicateID
		context["Tickets"] = tickets

		tmpl := templateHelpers.LoadTemplateFiles("syndicate-tickets.html", "templates/syndicate/tickets.html")
		tmpl.ExecuteTemplate(w, "layout", context)
	}
}