Billing

package domain

import (
	"fmt"
	"math"
)

// Paise is an integer amount of Indian paise (1 rupee = 100 paise). Every
// monetary value in this service — charge rates, invoice totals, line
// items, payments — is a Paise. Nothing in this package or any repository
// built on top of it performs float arithmetic on money.
type Paise int64

// Add returns the sum. It exists mainly so call sites read as money
// arithmetic rather than raw int64 addition, and so a future overflow
// guard has exactly one place to live.
func (p Paise) Add(other Paise) Paise {
	return p + other
}

// String renders paise as a rupee amount for display only — never for
// storage, comparison, or further arithmetic.
func (p Paise) String() string {
	rupees := int64(p) / 100
	remainder := int64(p) % 100
	if remainder < 0 {
		remainder = -remainder
	}
	return fmt.Sprintf("Rs.%d.%02d", rupees, remainder)
}

// ProrateBySqft computes a per-sqft charge for a given area, rounding
// half away from zero to the nearest paisa. Rates and areas both come
// from Postgres NUMERIC columns decoded as float64 at the repository
// boundary — this is the one deliberate, contained float computation in
// the service, and it happens exactly once per charge per invoice, never
// repeated or re-derived from a stored float later.
func ProrateBySqft(ratePerSqftPaise Paise, areaSqft float64) Paise {
	exact := float64(ratePerSqftPaise) * areaSqft
	if exact >= 0 {
		return Paise(math.Floor(exact + 0.5))
	}
	return Paise(-math.Floor(-exact + 0.5))
}

CREATE TABLE charge_types (
    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    tenant_id    UUID NOT NULL,
    code         TEXT NOT NULL,
    name         TEXT NOT NULL,
    rate_basis   TEXT NOT NULL CHECK (rate_basis IN ('flat_rate', 'per_sqft')),
    created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),

    UNIQUE (tenant_id, code)
);

CREATE INDEX charge_types_tenant_id_idx ON charge_types (tenant_id);

DROP TABLE IF EXISTS charge_types;

package domain

import (
	"errors"
	"time"

	"github.com/google/uuid"
)

type RateBasis string

const (
	RateBasisFlat    RateBasis = "flat_rate"
	RateBasisPerSqft RateBasis = "per_sqft"
)

type ChargeType struct {
	ID        uuid.UUID
	TenantID  uuid.UUID
	Code      string
	Name      string
	RateBasis RateBasis
	CreatedAt time.Time
}

var (
	ErrChargeTypeCodeTaken = errors.New("charge_type: code already exists for this tenant")
	ErrChargeTypeNotFound  = errors.New("charge_type: not found for this tenant")
	ErrInvalidRateBasis    = errors.New("charge_type: rate_basis must be flat_rate or per_sqft")
)

INSERT INTO charge_types (tenant_id, code, name, rate_basis)
VALUES ($1, $2, $3, $4)
RETURNING id, created_at;

-- Constraint names, not generic CRUD structure, define the translation:
-- charge_types_tenant_id_code_key -> ErrChargeTypeCodeTaken
-- charge_types_rate_basis_check   -> ErrInvalidRateBasis

type ChargeTypeRepository interface {
	Create(ctx context.Context, ct domain.ChargeType) (domain.ChargeType, error)
	List(ctx context.Context, tenantID uuid.UUID) ([]domain.ChargeType, error)
}

func (s *ChargeTypeService) Create(ctx context.Context, code, name string, basis domain.RateBasis) (domain.ChargeType, error) {
	tenantID := tenantctx.MustFromContext(ctx)
	if basis != domain.RateBasisFlat && basis != domain.RateBasisPerSqft {
		return domain.ChargeType{}, domain.ErrInvalidRateBasis
	}
	return s.repo.Create(ctx, domain.ChargeType{TenantID: tenantID, Code: code, Name: name, RateBasis: basis})
}

type createChargeTypeRequest struct {
	Code      string `json:"code" binding:"required"`
	Name      string `json:"name" binding:"required"`
	RateBasis string `json:"rate_basis" binding:"required"`
}

func (h *ChargeTypeHandler) Create(c *gin.Context) {
	// Binding and tenant middleware match the CRUD shape from Organization Service.
	ct, err := h.svc.Create(c.Request.Context(), req.Code, req.Name, domain.RateBasis(req.RateBasis))
	switch {
	case err == nil:
		c.JSON(http.StatusCreated, ct)
	case errors.Is(err, domain.ErrChargeTypeCodeTaken):
		c.JSON(http.StatusConflict, gin.H{"error": err.Error()})
	case errors.Is(err, domain.ErrInvalidRateBasis):
		c.JSON(http.StatusUnprocessableEntity, gin.H{"error": err.Error()})
	default:
		c.Error(err)
	}
}

chargeTypeRepo := postgres.NewChargeTypeRepository(pool)
chargeTypeSvc := service.NewChargeTypeService(chargeTypeRepo)
chargeTypeHandler := handler.NewChargeTypeHandler(chargeTypeSvc)

chargeTypes := router.Group("/charge-types")
chargeTypes.POST("", chargeTypeHandler.Create)
chargeTypes.GET("", chargeTypeHandler.List)