Ownership

package client

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"time"

	"github.com/google/uuid"
)

var ErrFlatNotFound = errors.New("flat_client: flat does not exist for this tenant")
var ErrFlatServiceUnavailable = errors.New("flat_client: flat-service did not respond")

type FlatClient struct {
	baseURL string
	http    *http.Client
}

func NewFlatClient(baseURL string) *FlatClient {
	return &FlatClient{baseURL: baseURL, http: &http.Client{Timeout: 3 * time.Second}}
}

// Exists asks flat-service directly rather than trusting the caller's
// claim that a flat_id is valid. tenantID is forwarded as the same
// header the gateway would send, so flat-service applies its own
// tenant_id filter — a flat_id that belongs to a different tenant comes
// back as 404 from flat-service, which this client turns into the same
// ErrFlatNotFound a nonexistent flat would produce.
func (c *FlatClient) Exists(ctx context.Context, tenantID, flatID uuid.UUID) (bool, error) {
	req, err := http.NewRequestWithContext(ctx, http.MethodGet,
		fmt.Sprintf("%s/flats/%s", c.baseURL, flatID), nil)
	if err != nil {
		return false, err
	}
	req.Header.Set("X-Tenant-Id", tenantID.String())

	resp, err := c.http.Do(req)
	if err != nil {
		return false, ErrFlatServiceUnavailable
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case http.StatusOK:
		return true, nil
	case http.StatusNotFound:
		return false, nil
	default:
		var body map[string]any
		_ = json.NewDecoder(resp.Body).Decode(&body)
		return false, fmt.Errorf("flat_client: unexpected status %d: %v", resp.StatusCode, body)
	}
}

CREATE TABLE flat_ownerships (
    id                 UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    tenant_id          UUID NOT NULL,
    flat_id            UUID NOT NULL, -- owned by flat-service; no FK across services
    resident_id        UUID NOT NULL REFERENCES residents(id),
    share_percentage   NUMERIC(5, 2) NOT NULL CHECK (share_percentage > 0 AND share_percentage <= 100),
    deed_reference     TEXT NOT NULL,
    effective_from     DATE NOT NULL,
    effective_to       DATE, -- NULL means "still the current owner"
    created_at         TIMESTAMPTZ NOT NULL DEFAULT now(),

    CHECK (effective_to IS NULL OR effective_to > effective_from)
);

CREATE INDEX flat_ownerships_tenant_flat_idx ON flat_ownerships (tenant_id, flat_id);
CREATE INDEX flat_ownerships_resident_id_idx ON flat_ownerships (resident_id);

-- A resident cannot hold two open (effective_to IS NULL) ownership
-- records for the same flat — that would be the same fact recorded twice.
CREATE UNIQUE INDEX flat_ownerships_open_resident_flat_key
    ON flat_ownerships (flat_id, resident_id)
    WHERE effective_to IS NULL;

DROP TABLE IF EXISTS flat_ownerships;

package postgres

import (
	"context"
	"errors"

	"github.com/google/uuid"
	"github.com/jackc/pgx/v5/pgxpool"

	"github.com/hoa-platform/backend/services/resident-service/internal/domain"
)

type OwnershipRepository struct {
	pool *pgxpool.Pool
}

func NewOwnershipRepository(pool *pgxpool.Pool) *OwnershipRepository {
	return &OwnershipRepository{pool: pool}
}

// CreateShare locks every open ownership row for this flat with
// SELECT ... FOR UPDATE before checking the running total. A concurrent
// second CreateShare call for the same flat blocks on that lock until
// the first transaction commits or rolls back, so the two calls are
// serialized instead of racing.
func (r *OwnershipRepository) CreateShare(ctx context.Context, o domain.FlatOwnership) (domain.FlatOwnership, error) {
	tx, err := r.pool.Begin(ctx)
	if err != nil {
		return domain.FlatOwnership{}, err
	}
	defer tx.Rollback(ctx)

	const lockAndSum = `
		SELECT COALESCE(SUM(share_percentage), 0)
		FROM flat_ownerships
		WHERE tenant_id = $1 AND flat_id = $2 AND effective_to IS NULL
		FOR UPDATE`

	var currentTotal float64
	if err := tx.QueryRow(ctx, lockAndSum, o.TenantID, o.FlatID).Scan(&currentTotal); err != nil {
		return domain.FlatOwnership{}, err
	}

	if currentTotal+o.SharePercentage > 100.0001 { // float tolerance for two-decimal percentages
		return domain.FlatOwnership{}, domain.ErrOwnershipSharesExceed100
	}

	const insert = `
		INSERT INTO flat_ownerships (tenant_id, flat_id, resident_id, share_percentage, deed_reference, effective_from)
		VALUES ($1, $2, $3, $4, $5, $6)
		RETURNING id, created_at`
	if err := tx.QueryRow(ctx, insert, o.TenantID, o.FlatID, o.ResidentID, o.SharePercentage, o.DeedReference, o.EffectiveFrom).
		Scan(&o.ID, &o.CreatedAt); err != nil {
		return domain.FlatOwnership{}, err
	}

	if err := tx.Commit(ctx); err != nil {
		return domain.FlatOwnership{}, err
	}
	return o, nil
}

// TransferOwnership closes the seller's open record and opens the
// buyer's in one transaction — a sale is one atomic fact, not two
// independent writes that could leave the flat with zero or two owners
// if the process crashed between them.
func (r *OwnershipRepository) TransferOwnership(
	ctx context.Context, tenantID, flatID, sellerResidentID, buyerResidentID uuid.UUID,
	deedReference string, effectiveDate string,
) error {
	tx, err := r.pool.Begin(ctx)
	if err != nil {
		return err
	}
	defer tx.Rollback(ctx)

	const closeSeller = `
		UPDATE flat_ownerships SET effective_to = $4
		WHERE tenant_id = $1 AND flat_id = $2 AND resident_id = $3 AND effective_to IS NULL`
	tag, err := tx.Exec(ctx, closeSeller, tenantID, flatID, sellerResidentID, effectiveDate)
	if err != nil {
		return err
	}
	if tag.RowsAffected() == 0 {
		return errors.New("ownership: seller has no open ownership record for this flat")
	}

	const openBuyer = `
		INSERT INTO flat_ownerships (tenant_id, flat_id, resident_id, share_percentage, deed_reference, effective_from)
		VALUES ($1, $2, $3, 100, $4, $5)`
	if _, err := tx.Exec(ctx, openBuyer, tenantID, flatID, buyerResidentID, deedReference, effectiveDate); err != nil {
		return err
	}

	return tx.Commit(ctx)
}

package domain

import (
	"errors"
	"time"

	"github.com/google/uuid"
)

type FlatOwnership struct {
	ID              uuid.UUID
	TenantID        uuid.UUID
	FlatID          uuid.UUID
	ResidentID      uuid.UUID
	SharePercentage float64
	DeedReference   string
	EffectiveFrom   time.Time
	EffectiveTo     *time.Time
	CreatedAt       time.Time
}

var ErrOwnershipSharesExceed100 = errors.New("ownership: shares for this flat would exceed 100 percent")
var ErrFlatNotFoundForOwnership = errors.New("ownership: flat does not exist for this tenant")

package service

import (
	"context"
	"errors"

	"github.com/google/uuid"

	"github.com/hoa-platform/backend/services/resident-service/internal/client"
	"github.com/hoa-platform/backend/services/resident-service/internal/domain"
)

type FlatChecker interface {
	Exists(ctx context.Context, tenantID, flatID uuid.UUID) (bool, error)
}

type OwnershipRepository interface {
	CreateShare(ctx context.Context, o domain.FlatOwnership) (domain.FlatOwnership, error)
}

type OwnershipService struct {
	repo  OwnershipRepository
	flats FlatChecker
}

func NewOwnershipService(repo OwnershipRepository, flats FlatChecker) *OwnershipService {
	return &OwnershipService{repo: repo, flats: flats}
}

func (s *OwnershipService) CreateShare(ctx context.Context, o domain.FlatOwnership) (domain.FlatOwnership, error) {
	exists, err := s.flats.Exists(ctx, o.TenantID, o.FlatID)
	if err != nil {
		if errors.Is(err, client.ErrFlatServiceUnavailable) {
			return domain.FlatOwnership{}, client.ErrFlatServiceUnavailable
		}
		return domain.FlatOwnership{}, err
	}
	if !exists {
		return domain.FlatOwnership{}, domain.ErrFlatNotFoundForOwnership
	}

	return s.repo.CreateShare(ctx, o)
}