CREATE TABLE id_mapping (
    id          BIGSERIAL PRIMARY KEY,
    entity_type VARCHAR(50) NOT NULL,  -- 'order', 'customer', 'price', etc.
    legacy_id   INTEGER NOT NULL,
    new_id      UUID NOT NULL DEFAULT gen_random_uuid(),
    migrated_at TIMESTAMPTZ,
    verified    BOOLEAN DEFAULT FALSE,
    UNIQUE (entity_type, legacy_id),
    UNIQUE (entity_type, new_id)
);

CREATE INDEX idx_id_mapping_legacy ON id_mapping (entity_type, legacy_id);
CREATE INDEX idx_id_mapping_new    ON id_mapping (entity_type, new_id);

-- Примеры:
-- ('order',    12345, '550e8400-e29b-41d4-a716-446655440000', NOW(), true)
-- ('customer', 67890, 'a1b2c3d4-e5f6-7890-abcd-ef1234567890', NOW(), false)
-- ('price',    42,    'b2c3d4e5-f6a7-8901-bcde-f12345678901', NOW(), true)

service IDMappingService {
  // Получить новый UUID по legacy ID
  rpc ResolveNewID(ResolveNewIDRequest) returns (ResolveNewIDResponse);
  // Получить legacy ID по новому UUID (для обратной совместимости)
  rpc ResolveLegacyID(ResolveLegacyIDRequest) returns (ResolveLegacyIDResponse);
  // Массовый маппинг (для batch-миграции)
  rpc BulkResolve(BulkResolveRequest) returns (BulkResolveResponse);
}

message ResolveNewIDRequest {
  string entity_type = 1;
  int32 legacy_id = 2;
}

message ResolveNewIDResponse {
  string new_id = 1; // UUID as string
  bool migrated = 2;
  bool verified = 3;
}

// internal/customer/acl/legacy_adapter.go
func (a *LegacyAdapter) GetCustomerByLegacyOrderID(ctx context.Context, legacyOrderID int32) (*domain.Customer, error) {
    // 1. Resolve legacy order → new order UUID
    orderUUID, err := a.idMapping.ResolveNewID(ctx, "order", legacyOrderID)
    if err != nil {
        return nil, fmt.Errorf("resolve order ID %d: %w", legacyOrderID, err)
    }

    // 2. Get order → extract customer_id
    order, err := a.orderRepo.GetByID(ctx, orderUUID)
    if err != nil {
        return nil, fmt.Errorf("get order %s: %w", orderUUID, err)
    }

    // 3. Get customer from Customer Core
    return a.customerClient.GetCustomer(ctx, order.CustomerID)
}

// internal/migration/acl/order_to_customer.go
package acl

type LegacyBookOrder struct {
    ID         int32   `db:"id"`
    FIO        string  `db:"fio"`
    Client     string  `db:"client"`
    Passport   string  `db:"passport"`
    CBirth     string  `db:"cbirth"`
    INN        string  `db:"inn"`
    OGRN       string  `db:"ogrn"`
    Org        string  `db:"org"`
    Tel        string  `db:"tel"`
    FinEmail   string  `db:"fin_email"`
    Town       string  `db:"town"`
    Street     string  `db:"street"`
    Home       string  `db:"home"`
    Flat       string  `db:"flat"`
    Coordinate string  `db:"coordinate"`
    ActualAddr string  `db:"actual_addr"`
    // ... остальные поля
}

func (acl *OrderACL) ToCustomer(order LegacyBookOrder) (*customerpb.CreateCustomerRequest, error) {
    customerType := customerpb.CustomerType_INDIVIDUAL
    if order.Client == "юр" || order.Client == "legal" {
        customerType = customerpb.CustomerType_LEGAL_ENTITY
    }

    // Parse passport: "1234 567890" → series + number
    series, number, err := parsePassport(order.Passport)
    if err != nil {
        return nil, fmt.Errorf("parse passport %q: %w", order.Passport, err)
    }

    // Parse coordinates: "55.123,37.456" → lat, lon
    lat, lon, _ := parseCoordinate(order.Coordinate) // best-effort

    // Normalize phone
    phone, _ := normalizePhone(order.Tel)

    req := &customerpb.CreateCustomerRequest{
        FullName:        strings.TrimSpace(order.FIO),
        Type:            customerType,
        PassportSeries:  series,
        PassportNumber:  number,
        Inn:             order.INN,
        Ogrn:            order.OGRN,
        OrganizationName: order.Org,
        Contacts: []*customerpb.Contact{},
        Addresses: []*customerpb.Address{},
    }

    if phone != "" {
        req.Contacts = append(req.Contacts, &customerpb.Contact{
            Type: customerpb.ContactType_PHONE, Value: phone, IsPrimary: true,
        })
    }
    if order.FinEmail != "" {
        req.Contacts = append(req.Contacts, &customerpb.Contact{
            Type: customerpb.ContactType_EMAIL, Value: strings.ToLower(strings.TrimSpace(order.FinEmail)),
        })
    }

    req.Addresses = append(req.Addresses, &customerpb.Address{
        City: order.Town, Street: order.Street, Building: order.Home,
        Apartment: order.Flat, FullAddress: order.ActualAddr,
        Latitude: lat, Longitude: lon, IsServiceAddress: true,
    })

    return req, nil
}

func parsePassport(raw string) (series, number string, err error) {
    parts := strings.Fields(strings.TrimSpace(raw))
    if len(parts) < 2 {
        return "", "", fmt.Errorf("expected 'series number', got %q", raw)
    }
    return parts[0], parts[1], nil
}

func normalizePhone(raw string) (string, error) {
    digits := strings.Map(func(r rune) rune {
        if r >= '0' && r <= '9' { return r }
        return -1
    }, raw)
    if len(digits) == 11 && digits[0] == '8' {
        digits = "7" + digits[1:]
    }
    if len(digits) != 11 {
        return "", fmt.Errorf("invalid phone: %q", raw)
    }
    return "+" + digits, nil
}

// internal/proxy/handlers/get_order.go
func (h *OrderHandler) GetOrder(w http.ResponseWriter, r *http.Request) {
    legacyID, _ := strconv.Atoi(chi.URLParam(r, "orderId"))

    // Feature flag: использовать новую систему?
    if h.features.IsEnabled("new_orders", r.Context()) {
        // Resolve legacy ID → new UUID
        newID, err := h.idMapping.ResolveNewID(r.Context(), "order", int32(legacyID))
        if err != nil {
            // Fallback: заказ ещё не мигрирован → читаем из Legacy
            h.proxyToLegacy(w, r)
            return
        }

        // Агрегация из новых сервисов
        order, _ := h.omsClient.GetOrder(r.Context(), newID)
        customer, _ := h.customerClient.GetCustomer(r.Context(), order.CustomerID)
        subscription, _ := h.productClient.GetSubscription(r.Context(), order.SubscriptionID)

        // Конвертировать обратно в Legacy-формат для старого UI
        legacyResponse := h.toLegacyOrderResponse(order, customer, subscription)
        json.NewEncoder(w).Encode(legacyResponse)
        return
    }

    h.proxyToLegacy(w, r)
}

// toLegacyOrderResponse — обратная конвертация для совместимости
func (h *OrderHandler) toLegacyOrderResponse(
    order *omspb.Order,
    customer *customerpb.Customer,
    subscription *productpb.Subscription,
) *LegacyGetOrderResponse {
    return &LegacyGetOrderResponse{
        Error: 0,
        Response: LegacyBookOrder{
            ID:        int32(order.LegacyId),
            FIO:       customer.FullName,
            Client:    mapCustomerType(customer.Type),
            Passport:  customer.PassportSeries + " " + customer.PassportNumber,
            Town:      extractCity(customer.Addresses),
            Street:    extractStreet(customer.Addresses),
            // ... остальные поля
            TP:        subscription.ProductOffering.Code,
            Status:    mapStatusToLegacy(order.Status),
            Priority:  int32(order.Priority),
        },
    }
}

enum OrderStatus {
  ORDER_STATUS_UNSPECIFIED = 0;
  ORDER_STATUS_NEW = 1;
  ORDER_STATUS_IN_PROGRESS = 2;
  ORDER_STATUS_COMPLETED = 3;
  ORDER_STATUS_CANCELLED = 4;
  ORDER_STATUS_ON_HOLD = 5;
  ORDER_STATUS_CLOSED = 6;
}

// internal/migration/dedup/customer_dedup.go
// Стратегия: группировка по (normalized_fio + passport) → один Customer.
type CustomerKey struct {
    NormalizedFIO string
    Passport      string
}

func DeduplicateCustomers(orders []LegacyBookOrder) map[CustomerKey][]LegacyBookOrder {
    groups := make(map[CustomerKey][]LegacyBookOrder)
    for _, o := range orders {
        key := CustomerKey{
            NormalizedFIO: normalizeString(o.FIO),
            Passport:      normalizeString(o.Passport),
        }
        groups[key] = append(groups[key], o)
    }
    return groups
    // Для каждой группы: создать одного Customer, привязать все заказы к нему.
}

// internal/auth/interceptor.go
// ConnectRPC interceptor для JWT-валидации
func NewAuthInterceptor(keycloakPublicKey *rsa.PublicKey) connect.UnaryInterceptorFunc {
    return func(next connect.UnaryFunc) connect.UnaryFunc {
        return func(ctx context.Context, req connect.AnyRequest) (connect.AnyResponse, error) {
            token := req.Header().Get("Authorization")
            claims, err := validateJWT(token, keycloakPublicKey)
            if err != nil {
                return nil, connect.NewError(connect.CodeUnauthenticated, err)
            }
            ctx = context.WithValue(ctx, userClaimsKey, claims)
            return next(ctx, req)
        }
    }
}