package service

import (
	"apskel-pos-be/internal/contract"
	"apskel-pos-be/internal/models"
	"apskel-pos-be/internal/processor"
	"apskel-pos-be/internal/transformer"
	"context"
	"strconv"

	"github.com/google/uuid"
)

type TableService struct {
	tableProcessor   *processor.TableProcessor
	tableTransformer *transformer.TableTransformer
}

func NewTableService(tableProcessor *processor.TableProcessor, tableTransformer *transformer.TableTransformer) *TableService {
	return &TableService{
		tableProcessor:   tableProcessor,
		tableTransformer: tableTransformer,
	}
}

func (s *TableService) Create(ctx context.Context, req contract.CreateTableRequest, organizationID uuid.UUID) (*contract.TableResponse, error) {
	modelReq := models.CreateTableRequest{
		OutletID:  req.OutletID,
		TableName: req.TableName,
		PositionX: req.PositionX,
		PositionY: req.PositionY,
		Capacity:  req.Capacity,
		Metadata:  req.Metadata,
	}

	response, err := s.tableProcessor.Create(ctx, modelReq, organizationID)
	if err != nil {
		return nil, err
	}

	return s.tableTransformer.ToContract(*response), nil
}

func (s *TableService) GetByID(ctx context.Context, id uuid.UUID) (*contract.TableResponse, error) {
	response, err := s.tableProcessor.GetByID(ctx, id)
	if err != nil {
		return nil, err
	}

	return s.tableTransformer.ToContract(*response), nil
}

func (s *TableService) Update(ctx context.Context, id uuid.UUID, req contract.UpdateTableRequest) (*contract.TableResponse, error) {
	modelReq := models.UpdateTableRequest{
		TableName: req.TableName,
		PositionX: req.PositionX,
		PositionY: req.PositionY,
		Capacity:  req.Capacity,
		IsActive:  req.IsActive,
		Metadata:  req.Metadata,
	}

	if req.Status != nil {
		status := models.TableStatus(*req.Status)
		modelReq.Status = &status
	}

	response, err := s.tableProcessor.Update(ctx, id, modelReq)
	if err != nil {
		return nil, err
	}

	return s.tableTransformer.ToContract(*response), nil
}

func (s *TableService) Delete(ctx context.Context, id uuid.UUID) error {
	return s.tableProcessor.Delete(ctx, id)
}

func (s *TableService) List(ctx context.Context, query contract.ListTablesQuery) (*contract.ListTablesResponse, error) {
	req := models.ListTablesRequest{
		Page:   query.Page,
		Limit:  query.Limit,
		Search: query.Search,
	}

	if query.OrganizationID != "" {
		if orgID, err := uuid.Parse(query.OrganizationID); err == nil {
			req.OrganizationID = &orgID
		}
	}

	if query.OutletID != "" {
		if outletID, err := uuid.Parse(query.OutletID); err == nil {
			req.OutletID = &outletID
		}
	}

	if query.Status != "" {
		status := models.TableStatus(query.Status)
		req.Status = &status
	}

	if query.IsActive != "" {
		if isActive, err := strconv.ParseBool(query.IsActive); err == nil {
			req.IsActive = &isActive
		}
	}

	response, err := s.tableProcessor.List(ctx, req)
	if err != nil {
		return nil, err
	}

	contractTables := make([]contract.TableResponse, len(response.Tables))
	for i, table := range response.Tables {
		contractTables[i] = *s.tableTransformer.ToContract(table)
	}

	return &contract.ListTablesResponse{
		Tables:     contractTables,
		TotalCount: response.TotalCount,
		Page:       response.Page,
		Limit:      response.Limit,
		TotalPages: response.TotalPages,
	}, nil
}

func (s *TableService) OccupyTable(ctx context.Context, tableID uuid.UUID, req contract.OccupyTableRequest) (*contract.TableResponse, error) {
	modelReq := models.OccupyTableRequest{
		OrderID:   req.OrderID,
		StartTime: req.StartTime,
	}

	response, err := s.tableProcessor.OccupyTable(ctx, tableID, modelReq)
	if err != nil {
		return nil, err
	}

	return s.tableTransformer.ToContract(*response), nil
}

func (s *TableService) ReleaseTable(ctx context.Context, tableID uuid.UUID, req contract.ReleaseTableRequest) (*contract.TableResponse, error) {
	modelReq := models.ReleaseTableRequest{
		PaymentAmount: req.PaymentAmount,
	}

	response, err := s.tableProcessor.ReleaseTable(ctx, tableID, modelReq)
	if err != nil {
		return nil, err
	}

	return s.tableTransformer.ToContract(*response), nil
}

func (s *TableService) GetAvailableTables(ctx context.Context, outletID uuid.UUID) ([]contract.TableResponse, error) {
	tables, err := s.tableProcessor.GetAvailableTables(ctx, outletID)
	if err != nil {
		return nil, err
	}

	responses := make([]contract.TableResponse, len(tables))
	for i, table := range tables {
		responses[i] = *s.tableTransformer.ToContract(table)
	}

	return responses, nil
}

func (s *TableService) GetOccupiedTables(ctx context.Context, outletID uuid.UUID) ([]contract.TableResponse, error) {
	tables, err := s.tableProcessor.GetOccupiedTables(ctx, outletID)
	if err != nil {
		return nil, err
	}

	responses := make([]contract.TableResponse, len(tables))
	for i, table := range tables {
		responses[i] = *s.tableTransformer.ToContract(table)
	}

	return responses, nil
}