Vendors

package domain

import (
	"errors"
	"time"
)

type VerificationStatus string

const (
	VerificationPending  VerificationStatus = "pending"
	VerificationVerified VerificationStatus = "verified"
	VerificationRejected VerificationStatus = "rejected"
)

var ErrInvalidContractWindow = errors.New("contract end must be after contract start")

type ContractWindow struct {
	start time.Time
	end   *time.Time
}

func NewContractWindow(start time.Time, end *time.Time) (ContractWindow, error) {
	if end != nil && !end.After(start) {
		return ContractWindow{}, ErrInvalidContractWindow
	}
	return ContractWindow{start: start, end: end}, nil
}

func (w ContractWindow) ActiveAt(at time.Time) bool {
	if at.Before(w.start) {
		return false
	}
	return w.end == nil || at.Before(*w.end)
}

type Vendor struct {
	id             string
	organizationID string
	companyName    string
	category       string
	window         ContractWindow
	verification   VerificationStatus
}

func Onboard(id, organizationID, companyName, category string, window ContractWindow) *Vendor {
	return &Vendor{id, organizationID, companyName, category, window, VerificationPending}
}

func (v *Vendor) Verify()  { v.verification = VerificationVerified }
func (v *Vendor) Reject()  { v.verification = VerificationRejected }

// EligibleForAssignment returns false for anything but a verified vendor
// with a contract window that covers the given instant. Callers never
// check the two conditions separately, which would let a stale contract
// sneak through.
func (v *Vendor) EligibleForAssignment(at time.Time) bool {
	return v.verification == VerificationVerified && v.window.ActiveAt(at)
}

func (v *Vendor) ID() string             { return v.id }
func (v *Vendor) OrganizationID() string { return v.organizationID }

CREATE TYPE vendor_verification AS ENUM ('pending', 'verified', 'rejected');

CREATE TABLE vendors (
    id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
    organization_id uuid NOT NULL, -- validated through organization-service
    company_name text NOT NULL,
    category text NOT NULL,
    contract_start date NOT NULL,
    contract_end date,
    verification vendor_verification NOT NULL DEFAULT 'pending',
    created_at timestamptz NOT NULL DEFAULT now()
);

CREATE TABLE vendor_assignments (
    id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
    organization_id uuid NOT NULL,
    vendor_id uuid NOT NULL REFERENCES vendors (id),
    external_reference text NOT NULL, -- opaque complaint or work-order ID; staff-service does not join to it
    assigned_at timestamptz NOT NULL DEFAULT now(),
    released_at timestamptz
);

CREATE INDEX idx_vendor_assignments_vendor ON vendor_assignments (organization_id, vendor_id, released_at);

package httpadapter

import (
	"errors"
	"net/http"

	"github.com/gin-gonic/gin"

	"github.com/hoa-platform/backend/pkg/servicecreds"
	"github.com/hoa-platform/backend/services/staff-service/internal/application"
)

type VendorAssignmentHandler struct {
	assign *application.AssignVendor
}

func NewVendorAssignmentHandler(assign *application.AssignVendor) (*VendorAssignmentHandler, error) {
	if assign == nil {
		return nil, errors.New("assign vendor use case is required")
	}
	return &VendorAssignmentHandler{assign: assign}, nil
}

type assignVendorRequest struct {
	ExternalReference string `json:"external_reference" binding:"required"`
}

// Assign is only reachable through the internal service mesh: servicecreds
// verifies a signed service-identity token, not a resident or staff JWT.
func (h *VendorAssignmentHandler) Assign(c *gin.Context) {
	caller, err := servicecreds.FromContext(c.Request.Context())
	if err != nil || caller.ServiceName != "complaint-service" {
		c.JSON(http.StatusForbidden, gin.H{"code": "service_not_authorized"})
		return
	}

	var req assignVendorRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusUnprocessableEntity, gin.H{"code": "validation_failed"})
		return
	}

	assignment, err := h.assign.Execute(c.Request.Context(), application.AssignVendorCommand{
		TenantID:           caller.TenantID,
		VendorID:           c.Param("vendorID"),
		ExternalReference:  req.ExternalReference,
	})
	switch {
	case errors.Is(err, application.ErrVendorNotEligible):
		c.JSON(http.StatusConflict, gin.H{"code": "vendor_not_eligible"})
		return
	case errors.Is(err, application.ErrNotFound):
		c.JSON(http.StatusNotFound, gin.H{"code": "vendor_not_found"})
		return
	case err != nil:
		c.JSON(http.StatusInternalServerError, gin.H{"code": "internal_error"})
		return
	}

	c.JSON(http.StatusCreated, assignment)
}