package controller

import (
	"narasi-ahli-be/app/module/chat_history/request"
	"narasi-ahli-be/app/module/chat_history/service"
	"narasi-ahli-be/utils/paginator"
	utilRes "narasi-ahli-be/utils/response"
	utilVal "narasi-ahli-be/utils/validator"
	"strconv"

	"github.com/gofiber/fiber/v2"
	"github.com/rs/zerolog"
)

type chatHistoryController struct {
	chatHistoryService service.ChatHistoryService
	Log                zerolog.Logger
}

type ChatHistoryController interface {
	// Chat History Sessions
	GetUserSessions(c *fiber.Ctx) error
	GetSession(c *fiber.Ctx) error
	CreateSession(c *fiber.Ctx) error
	UpdateSession(c *fiber.Ctx) error
	DeleteSession(c *fiber.Ctx) error

	// Chat History Messages
	GetSessionMessages(c *fiber.Ctx) error
	CreateMessage(c *fiber.Ctx) error
	UpdateMessage(c *fiber.Ctx) error
	DeleteMessage(c *fiber.Ctx) error

	// Combined operations
	SaveChatHistory(c *fiber.Ctx) error
}

func NewChatHistoryController(chatHistoryService service.ChatHistoryService, log zerolog.Logger) ChatHistoryController {
	return &chatHistoryController{
		chatHistoryService: chatHistoryService,
		Log:                log,
	}
}

// Get User Sessions
// @Summary      Get user chat history sessions
// @Description  API for getting all chat history sessions for authenticated user
// @Tags         Chat History
// @Security     Bearer
// @Param        X-Client-Key header string false "Insert the X-Client-Key"
// @Param        req query request.ChatHistorySessionsQueryRequest false "query parameters"
// @Param        req query paginator.Pagination false "pagination parameters"
// @Success      200  {object}  response.Response
// @Failure      400  {object}  response.BadRequestError
// @Failure      401  {object}  response.UnauthorizedError
// @Failure      500  {object}  response.InternalServerError
// @Router       /chat-history/sessions [get]
func (_i *chatHistoryController) GetUserSessions(c *fiber.Ctx) error {
	paginate, err := paginator.Paginate(c)
	if err != nil {
		return err
	}

	authHeader := c.Get("Authorization")

	reqContext := request.ChatHistorySessionsQueryRequestContext{
		AgentID:   c.Query("agent_id"),
		SessionID: c.Query("session_id"),
	}
	req := reqContext.ToParamRequest()
	req.Pagination = paginate

	sessionsData, paging, err := _i.chatHistoryService.GetUserSessions(authHeader, req)
	if err != nil {
		return err
	}

	return utilRes.Resp(c, utilRes.Response{
		Success:  true,
		Messages: utilRes.Messages{"Chat history sessions successfully retrieved"},
		Data:     sessionsData,
		Meta:     paging,
	})
}

// Get Session
// @Summary      Get one chat history session with messages
// @Description  API for getting one chat history session with all its messages
// @Tags         Chat History
// @Security     Bearer
// @Param        X-Client-Key header string false "Insert the X-Client-Key"
// @Param        sessionId path string true "Session ID"
// @Success      200  {object}  response.Response
// @Failure      400  {object}  response.BadRequestError
// @Failure      401  {object}  response.UnauthorizedError
// @Failure      500  {object}  response.InternalServerError
// @Router       /chat-history/sessions/{sessionId} [get]
func (_i *chatHistoryController) GetSession(c *fiber.Ctx) error {
	sessionID := c.Params("sessionId")
	if sessionID == "" {
		return utilRes.Resp(c, utilRes.Response{
			Success:  false,
			Messages: utilRes.Messages{"Session ID is required"},
		})
	}

	authHeader := c.Get("Authorization")

	sessionData, err := _i.chatHistoryService.GetSession(authHeader, sessionID)
	if err != nil {
		return err
	}

	return utilRes.Resp(c, utilRes.Response{
		Success:  true,
		Messages: utilRes.Messages{"Chat history session successfully retrieved"},
		Data:     sessionData,
	})
}

// Create Session
// @Summary      Create chat history session
// @Description  API for create chat history session
// @Tags         Chat History
// @Security     Bearer
// @Param        X-Client-Key header string false "Insert the X-Client-Key"
// @Param        X-Csrf-Token header string true "Insert the X-Csrf-Token"
// @Param        Authorization header string false "Insert your access token" default(Bearer <Add access token here>)
// @Param        payload body request.ChatHistorySessionsCreateRequest true "Required payload"
// @Success      200  {object}  response.Response
// @Failure      400  {object}  response.BadRequestError
// @Failure      401  {object}  response.UnauthorizedError
// @Failure      500  {object}  response.InternalServerError
// @Router       /chat-history/sessions [post]
func (_i *chatHistoryController) CreateSession(c *fiber.Ctx) error {
	req := new(request.ChatHistorySessionsCreateRequest)
	if err := utilVal.ParseAndValidate(c, req); err != nil {
		return err
	}

	authHeader := c.Get("Authorization")

	dataResult, err := _i.chatHistoryService.CreateSession(authHeader, *req)
	if err != nil {
		return err
	}

	return utilRes.Resp(c, utilRes.Response{
		Success:  true,
		Messages: utilRes.Messages{"Chat history session successfully created"},
		Data:     dataResult,
	})
}

// Update Session
// @Summary      Update chat history session
// @Description  API for update chat history session
// @Tags         Chat History
// @Security     Bearer
// @Param        X-Client-Key header string false "Insert the X-Client-Key"
// @Param        X-Csrf-Token header string true "Insert the X-Csrf-Token"
// @Param        sessionId path string true "Session ID"
// @Param        payload body request.ChatHistorySessionsUpdateRequest true "Required payload"
// @Success      200  {object}  response.Response
// @Failure      400  {object}  response.BadRequestError
// @Failure      401  {object}  response.UnauthorizedError
// @Failure      500  {object}  response.InternalServerError
// @Router       /chat-history/sessions/{sessionId} [put]
func (_i *chatHistoryController) UpdateSession(c *fiber.Ctx) error {
	sessionID := c.Params("sessionId")
	if sessionID == "" {
		return utilRes.Resp(c, utilRes.Response{
			Success:  false,
			Messages: utilRes.Messages{"Session ID is required"},
		})
	}

	req := new(request.ChatHistorySessionsUpdateRequest)
	if err := utilVal.ParseAndValidate(c, req); err != nil {
		return err
	}

	authHeader := c.Get("Authorization")

	err := _i.chatHistoryService.UpdateSession(authHeader, sessionID, *req)
	if err != nil {
		return err
	}

	return utilRes.Resp(c, utilRes.Response{
		Success:  true,
		Messages: utilRes.Messages{"Chat history session successfully updated"},
	})
}

// Delete Session
// @Summary      Delete chat history session
// @Description  API for delete chat history session
// @Tags         Chat History
// @Security     Bearer
// @Param        X-Client-Key header string false "Insert the X-Client-Key"
// @Param        X-Csrf-Token header string true "Insert the X-Csrf-Token"
// @Param        sessionId path string true "Session ID"
// @Success      200  {object}  response.Response
// @Failure      400  {object}  response.BadRequestError
// @Failure      401  {object}  response.UnauthorizedError
// @Failure      500  {object}  response.InternalServerError
// @Router       /chat-history/sessions/{sessionId} [delete]
func (_i *chatHistoryController) DeleteSession(c *fiber.Ctx) error {
	sessionID := c.Params("sessionId")
	if sessionID == "" {
		return utilRes.Resp(c, utilRes.Response{
			Success:  false,
			Messages: utilRes.Messages{"Session ID is required"},
		})
	}

	authHeader := c.Get("Authorization")

	err := _i.chatHistoryService.DeleteSession(authHeader, sessionID)
	if err != nil {
		return err
	}

	return utilRes.Resp(c, utilRes.Response{
		Success:  true,
		Messages: utilRes.Messages{"Chat history session successfully deleted"},
	})
}

// Get Session Messages
// @Summary      Get chat history session messages
// @Description  API for getting all messages in a chat history session
// @Tags         Chat History
// @Security     Bearer
// @Param        X-Client-Key header string false "Insert the X-Client-Key"
// @Param        sessionId path string true "Session ID"
// @Param        req query request.ChatHistoryMessagesQueryRequest false "query parameters"
// @Param        req query paginator.Pagination false "pagination parameters"
// @Success      200  {object}  response.Response
// @Failure      400  {object}  response.BadRequestError
// @Failure      401  {object}  response.UnauthorizedError
// @Failure      500  {object}  response.InternalServerError
// @Router       /chat-history/sessions/{sessionId}/messages [get]
func (_i *chatHistoryController) GetSessionMessages(c *fiber.Ctx) error {
	sessionID := c.Params("sessionId")
	if sessionID == "" {
		return utilRes.Resp(c, utilRes.Response{
			Success:  false,
			Messages: utilRes.Messages{"Session ID is required"},
		})
	}

	paginate, err := paginator.Paginate(c)
	if err != nil {
		return err
	}

	authHeader := c.Get("Authorization")

	req := request.ChatHistoryMessagesQueryRequest{
		SessionID:  sessionID,
		Pagination: paginate,
	}

	messagesData, paging, err := _i.chatHistoryService.GetSessionMessages(authHeader, sessionID, req)
	if err != nil {
		return err
	}

	return utilRes.Resp(c, utilRes.Response{
		Success:  true,
		Messages: utilRes.Messages{"Chat history messages successfully retrieved"},
		Data:     messagesData,
		Meta:     paging,
	})
}

// Create Message
// @Summary      Create chat history message
// @Description  API for creating a message in a chat history session
// @Tags         Chat History
// @Security     Bearer
// @Param        X-Client-Key header string false "Insert the X-Client-Key"
// @Param        X-Csrf-Token header string true "Insert the X-Csrf-Token"
// @Param        sessionId path string true "Session ID"
// @Param        payload body request.ChatHistoryMessagesCreateRequest true "Required payload"
// @Success      200  {object}  response.Response
// @Failure      400  {object}  response.BadRequestError
// @Failure      401  {object}  response.UnauthorizedError
// @Failure      500  {object}  response.InternalServerError
// @Router       /chat-history/sessions/{sessionId}/messages [post]
func (_i *chatHistoryController) CreateMessage(c *fiber.Ctx) error {
	sessionID := c.Params("sessionId")
	if sessionID == "" {
		return utilRes.Resp(c, utilRes.Response{
			Success:  false,
			Messages: utilRes.Messages{"Session ID is required"},
		})
	}

	req := new(request.ChatHistoryMessagesCreateRequest)
	if err := utilVal.ParseAndValidate(c, req); err != nil {
		return err
	}

	// Set session ID from URL parameter
	req.SessionID = sessionID

	authHeader := c.Get("Authorization")

	dataResult, err := _i.chatHistoryService.CreateMessage(authHeader, *req)
	if err != nil {
		return err
	}

	return utilRes.Resp(c, utilRes.Response{
		Success:  true,
		Messages: utilRes.Messages{"Chat history message successfully created"},
		Data:     dataResult,
	})
}

// Update Message
// @Summary      Update chat history message
// @Description  API for update chat history message
// @Tags         Chat History
// @Security     Bearer
// @Param        X-Client-Key header string false "Insert the X-Client-Key"
// @Param        X-Csrf-Token header string true "Insert the X-Csrf-Token"
// @Param        messageId path int true "Message ID"
// @Param        payload body request.ChatHistoryMessagesUpdateRequest true "Required payload"
// @Success      200  {object}  response.Response
// @Failure      400  {object}  response.BadRequestError
// @Failure      401  {object}  response.UnauthorizedError
// @Failure      500  {object}  response.InternalServerError
// @Router       /chat-history/messages/{messageId} [put]
func (_i *chatHistoryController) UpdateMessage(c *fiber.Ctx) error {
	messageId, err := strconv.ParseUint(c.Params("messageId"), 10, 0)
	if err != nil {
		return err
	}

	req := new(request.ChatHistoryMessagesUpdateRequest)
	if err := utilVal.ParseAndValidate(c, req); err != nil {
		return err
	}

	authHeader := c.Get("Authorization")

	if err := _i.chatHistoryService.UpdateMessage(authHeader, uint(messageId), *req); err != nil {
		return err
	}

	return utilRes.Resp(c, utilRes.Response{
		Success:  true,
		Messages: utilRes.Messages{"Chat history message successfully updated"},
	})
}

// Delete Message
// @Summary      Delete chat history message
// @Description  API for delete chat history message
// @Tags         Chat History
// @Security     Bearer
// @Param        X-Client-Key header string false "Insert the X-Client-Key"
// @Param        X-Csrf-Token header string true "Insert the X-Csrf-Token"
// @Param        messageId path int true "Message ID"
// @Success      200  {object}  response.Response
// @Failure      400  {object}  response.BadRequestError
// @Failure      401  {object}  response.UnauthorizedError
// @Failure      500  {object}  response.InternalServerError
// @Router       /chat-history/messages/{messageId} [delete]
func (_i *chatHistoryController) DeleteMessage(c *fiber.Ctx) error {
	messageId, err := strconv.ParseUint(c.Params("messageId"), 10, 0)
	if err != nil {
		return err
	}

	authHeader := c.Get("Authorization")

	if err := _i.chatHistoryService.DeleteMessage(authHeader, uint(messageId)); err != nil {
		return err
	}

	return utilRes.Resp(c, utilRes.Response{
		Success:  true,
		Messages: utilRes.Messages{"Chat history message successfully deleted"},
	})
}

// Save Chat History
// @Summary      Save chat history (sessions and messages)
// @Description  API for saving complete chat history including sessions and messages
// @Tags         Chat History
// @Security     Bearer
// @Param        X-Client-Key header string false "Insert the X-Client-Key"
// @Param        X-Csrf-Token header string true "Insert the X-Csrf-Token"
// @Param        Authorization header string false "Insert your access token" default(Bearer <Add access token here>)
// @Param        payload body request.ChatHistorySessionsCreateRequest true "Required payload"
// @Success      200  {object}  response.Response
// @Failure      400  {object}  response.BadRequestError
// @Failure      401  {object}  response.UnauthorizedError
// @Failure      500  {object}  response.InternalServerError
// @Router       /chat-history/save [post]
func (_i *chatHistoryController) SaveChatHistory(c *fiber.Ctx) error {
	req := new(request.ChatHistorySessionsCreateRequest)
	if err := utilVal.ParseAndValidate(c, req); err != nil {
		return err
	}

	authHeader := c.Get("Authorization")

	dataResult, err := _i.chatHistoryService.SaveChatHistory(authHeader, *req)
	if err != nil {
		return err
	}

	return utilRes.Resp(c, utilRes.Response{
		Success:  true,
		Messages: utilRes.Messages{"Chat history saved successfully"},
		Data:     dataResult,
	})
}