package handler

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

	"git.kundeng.us/phoenix/textsender-models/tx0/message"
	"git.kundeng.us/phoenix/textsender-models/tx0/types"
	"github.com/google/uuid"

	"git.kundeng.us/phoenix/textsender-api/internal/app"
	"git.kundeng.us/phoenix/textsender-api/internal/store"
)

type EventResponseHandler struct {
	App                       *app.App
	MessageEventResponseStore store.MessageEventResponseStore
}

func NewEventResponseHandler(apiApp *app.App, str store.MessageEventResponseStore) *EventResponseHandler {
	return &EventResponseHandler{App: apiApp, MessageEventResponseStore: str}
}

type RecordEventRequest struct {
	ScheduledMessageEventId uuid.UUID   `json:"scheduled_message_event_id"`
	Response                types.JSONB `json:"response"`
	UserId                  uuid.UUID   `json:"user_id"`
	Sent                    *time.Time  `json:"sent,omitempty"`
	Status                  string      `json:"status"`
	ContactId               *uuid.UUID  `json:"contact_id"`
	MessageId               *uuid.UUID  `json:"message_id"`
}

type RecordEventResponse struct {
	Message string                          `json:"message"`
	Data    []*message.MessageEventResponse `json:"data"`
}

func (e *EventResponseHandler) RecordResponse(w http.ResponseWriter, r *http.Request) {
	var req RecordEventRequest
	if err := ExtractFromRequest(r, &req); err != nil {
		http.Error(w, "Invalid JSON: "+err.Error(), http.StatusBadRequest)
	}
	defer r.Body.Close()

	var statusCode int
	var rp message.MessageEventResponse
	var resp RecordEventResponse

	defer RespondWithJSON(w, statusCode, &resp)

	if req.Sent == nil {
		statusCode = http.StatusBadRequest
		resp.Message = "Sent time is empty"
	} else if req.UserId == uuid.Nil {
		statusCode = http.StatusBadRequest
		resp.Message = "User Id is empty"
	} else if len(req.Response) == 0 {
		statusCode = http.StatusBadRequest
		resp.Message = "Response is empty"
	} else if req.ScheduledMessageEventId == uuid.Nil {
		statusCode = http.StatusBadRequest
		resp.Message = "Scheduled message event Id is empty"
	} else {
		log.Println("Starting process to record Message Event Response")
		rp.ScheduledMessageEventId = req.ScheduledMessageEventId
		fmt.Println(req.Response)
		rp.Response = req.Response
		rp.UserId = req.UserId
		rp.Sent = *req.Sent

		switch req.Status {
		case message.Message_Event_Response_Status_Instant: {
			log.Println("Status:", req.Status)
			rp.Status = req.Status
			rp.MessageId = req.MessageId
			rp.ContactId = req.ContactId
		}
		case message.Message_Event_Response_Status_Scheduled: {
			log.Println("Status:", req.Status)
			rp.Status = req.Status
		}
		default: {
			statusCode = http.StatusBadRequest
			resp.Message = "Status is invalid"
		}
		}

		ctx := r.Context()
		if err := e.MessageEventResponseStore.Create(ctx, &rp); err != nil {
			log.Println("Error:", err)
			resp.Message = err.Error()
			statusCode = http.StatusInternalServerError
		} else {
			log.Println("Created Message Event Response")
			statusCode = http.StatusCreated
			resp.Message = "Successful"
			resp.Data = append(resp.Data, &rp)
		}
	}
}

type GetMessageEventResponseFetchedResponse struct {
	Message string `json:"message"`
	Data []*message.MessageEventResponse `json:"data"`
}

func (e *EventResponseHandler) Fetch(w http.ResponseWriter, r *http.Request) {
	queryParams := r.URL.Query()
	var userId uuid.UUID

	if _, exists := queryParams["user_id"]; !exists {
		http.Error(w, "Query params", http.StatusBadRequest)
		return
	} else {
		var err error
		userId, err = uuid.Parse(queryParams.Get("user_id"))
		if err != nil {
			http.Error(w, "Query params", http.StatusBadRequest)
			return
		}
	}

	var statusCode int
	var resp GetMessageEventResponseFetchedResponse

	if userId == uuid.Nil {
		statusCode = http.StatusBadRequest
		resp.Message = "User Id is nil"
	} else {
		ctx := r.Context()
		if sentMessages, err := e.MessageEventResponseStore.GetWithUserId(ctx, userId); err != nil {
			statusCode = http.StatusInternalServerError
			resp.Message = err.Error()
		} else {
			if len(sentMessages) == 0 {
				statusCode = http.StatusNotFound
				resp.Message = "Not MessageEventResponses found"
			} else {
				statusCode = http.StatusOK
				resp.Message = "Successful"
				resp.Data = sentMessages
			}
		}
	}

	RespondWithJSON(w, statusCode, &resp)
}