package transformer

import (
	"apskel-pos-be/internal/contract"
	"apskel-pos-be/internal/models"
)

func CreateExpenseRequestToModel(req *contract.CreateExpenseRequest) *models.CreateExpenseRequest {
	items := make([]models.CreateExpenseItemRequest, len(req.Items))
	for i, item := range req.Items {
		items[i] = CreateExpenseItemRequestToModel(&item)
	}

	return &models.CreateExpenseRequest{
		ExpenseName:     req.ExpenseName,
		Receiver:        req.Receiver,
		TransactionDate: req.TransactionDate,
		CodeNumber:      req.CodeNumber,
		OutletID:        req.OutletID,
		Description:     req.Description,
		Tax:             req.Tax,
		Total:           req.Total,
		Items:           items,
	}
}

func CreateExpenseItemRequestToModel(req *contract.CreateExpenseItemRequest) models.CreateExpenseItemRequest {
	return models.CreateExpenseItemRequest{
		ChartOfAccountID: req.ChartOfAccountID,
		Description:      req.Description,
		Amount:           req.Amount,
	}
}

func UpdateExpenseRequestToModel(req *contract.UpdateExpenseRequest) *models.UpdateExpenseRequest {
	modelReq := &models.UpdateExpenseRequest{
		ExpenseName:     req.ExpenseName,
		Receiver:        req.Receiver,
		TransactionDate: req.TransactionDate,
		CodeNumber:      req.CodeNumber,
		OutletID:        req.OutletID,
		Description:     req.Description,
		Tax:             req.Tax,
		Total:           req.Total,
		Reserved1:       req.Reserved1,
	}

	if req.Items != nil {
		items := make([]models.UpdateExpenseItemRequest, len(req.Items))
		for i, item := range req.Items {
			items[i] = UpdateExpenseItemRequestToModel(&item)
		}
		modelReq.Items = items
	}

	return modelReq
}

func UpdateExpenseItemRequestToModel(req *contract.UpdateExpenseItemRequest) models.UpdateExpenseItemRequest {
	return models.UpdateExpenseItemRequest{
		ChartOfAccountID: req.ChartOfAccountID,
		Description:      req.Description,
		Amount:           req.Amount,
	}
}

func ListExpenseRequestToModel(req *contract.ListExpenseRequest) *models.ListExpenseRequest {
	return &models.ListExpenseRequest{
		Page:      req.Page,
		Limit:     req.Limit,
		Search:    req.Search,
		OutletID:  req.OutletID,
		StartDate: req.StartDate,
		EndDate:   req.EndDate,
	}
}

func ExpenseModelResponseToResponse(expense *models.ExpenseResponse) *contract.ExpenseResponse {
	if expense == nil {
		return nil
	}

	items := make([]contract.ExpenseItemResponse, len(expense.Items))
	for i, item := range expense.Items {
		items[i] = ExpenseItemModelResponseToResponse(&item)
	}

	return &contract.ExpenseResponse{
		ID:              expense.ID,
		OrganizationID:  expense.OrganizationID,
		OutletID:        expense.OutletID,
		ExpenseName:     expense.ExpenseName,
		Receiver:        expense.Receiver,
		TransactionDate: expense.TransactionDate,
		CodeNumber:      expense.CodeNumber,
		Description:     expense.Description,
		Tax:             expense.Tax,
		Total:           expense.Total,
		Reserved1:       expense.Reserved1,
		CreatedAt:       expense.CreatedAt,
		UpdatedAt:       expense.UpdatedAt,
		Items:           items,
	}
}

func ExpenseItemModelResponseToResponse(item *models.ExpenseItemResponse) contract.ExpenseItemResponse {
	return contract.ExpenseItemResponse{
		ID:                 item.ID,
		ExpenseID:          item.ExpenseID,
		ChartOfAccountID:   item.ChartOfAccountID,
		ChartOfAccountName: item.ChartOfAccountName,
		Description:        item.Description,
		Amount:             item.Amount,
		CreatedAt:          item.CreatedAt,
		UpdatedAt:          item.UpdatedAt,
	}
}

func ExpenseModelResponsesToResponses(expenses []*models.ExpenseResponse) []contract.ExpenseResponse {
	if expenses == nil {
		return nil
	}

	responses := make([]contract.ExpenseResponse, len(expenses))
	for i, expense := range expenses {
		response := ExpenseModelResponseToResponse(expense)
		if response != nil {
			responses[i] = *response
		}
	}
	return responses
}