package service

import (
	"database/sql"

	"github.com/wmms/wmms/internal/model"
	"github.com/wmms/wmms/internal/repository"
)

type StockService struct {
	stockRepo *repository.StockRepo
}

func NewStockService() *StockService {
	return &StockService{
		stockRepo: repository.NewStockRepo(),
	}
}

func (s *StockService) GetAllStock(search, category string, limit, offset int) ([]model.Stock, int64, error) {
	return s.stockRepo.GetAllStock(search, category, limit, offset)
}

func (s *StockService) GetByMaterialID(materialID int64) (*model.Stock, error) {
	return s.stockRepo.GetByMaterialID(materialID)
}

func (s *StockService) GetWarningStock(limit, offset int) ([]model.Stock, int64, error) {
	return s.stockRepo.GetWarningStock(limit, offset)
}

func (s *StockService) GetLogsByMaterialID(materialID int64, limit, offset int) ([]model.StockLogResponse, int64, error) {
	logs, total, err := s.stockRepo.GetLogsByMaterialID(materialID, limit, offset)
	if err != nil {
		return nil, 0, err
	}

	var responses []model.StockLogResponse
	balance := 0
	for _, log := range logs {
		if log.Type == "in" {
			balance += log.Quantity
		} else {
			balance -= log.Quantity
		}

		changeType := "outbound"
		if log.Type == "in" {
			changeType = "inbound"
		}

		beforeQuantity := balance - log.Quantity
		if log.Type != "in" {
			beforeQuantity = balance + log.Quantity
		}

		responses = append(responses, model.StockLogResponse{
			ID:             log.ID,
			MaterialID:     log.MaterialID,
			ChangeType:     changeType,
			ChangeQuantity: log.Quantity,
			BeforeQuantity: beforeQuantity,
			AfterQuantity:  balance,
			ReferenceID:    log.RelatedOrderID,
			ReferenceType:  log.RelatedOrderType,
			CreatedAt:      log.CreatedAt,
		})
	}
	return responses, total, nil
}

func (s *StockService) GetAllLogs(limit, offset int) ([]model.StockLogResponse, int64, error) {
	logs, total, err := s.stockRepo.GetAllLogsWithBalance(limit, offset)
	if err != nil {
		return nil, 0, err
	}

	var responses []model.StockLogResponse
	for _, log := range logs {
		changeType := "outbound"
		if log.Type == "in" {
			changeType = "inbound"
		}

		beforeQuantity := log.RunningBalance - log.Quantity
		if log.Type != "in" {
			beforeQuantity = log.RunningBalance + log.Quantity
		}

		// inbound=+quantity, outbound=-quantity
		changeQuantity := log.Quantity
		if log.Type != "in" {
			changeQuantity = -log.Quantity
		}

		responses = append(responses, model.StockLogResponse{
			ID:             log.ID,
			MaterialID:     log.MaterialID,
			ChangeType:     changeType,
			ChangeQuantity: changeQuantity,
			BeforeQuantity: beforeQuantity,
			AfterQuantity:  log.RunningBalance,
			ReferenceID:    log.RelatedOrderID,
			ReferenceType:  log.RelatedOrderType,
			CreatedAt:      log.CreatedAt,
		})
	}
	return responses, total, nil
}

func (s *StockService) MaterialExists(materialID int64) (bool, error) {
	_, err := s.stockRepo.GetByMaterialID(materialID)
	if err == sql.ErrNoRows {
		return false, nil
	}
	if err != nil {
		return false, err
	}
	return true, nil
}