graph TB
    subgraph "Внешние системы"
        L[Лента Pickup API + парсинг]
        M[METRO EDI]
        G[Globus API]
        V[ВкусВилл API]
        SB[Super Babylon]
        TB[Т-Банк API]
        SBP[СБП]
        SMS[SMS-провайдер]
        FCM[FCM/Push]
        YE[Yandex.Eda]
        KM[Komus]
        AL[Aloe]
    end
    subgraph "API Gateway"
        GW[Nginx / Traefik]
    end
    subgraph "Внутренние сервисы"
        AUTH[Auth Service]
        CAT[Catalog Service]
        CART[Cart Service]
        ORD[Order Service]
        PAY[Payment Service]
        PICK[Picker Service]
        DEL[Delivery Service]
        DISP[Dispatcher]
        ETA[ETA Estimator]
        NOTIF[Notification Service]
        INV[Inventory Service]
        ADMIN[Admin API]
    end
    subgraph "Хранилища"
        PG[(PostgreSQL)]
        RD[(Redis)]
        ES[(Elasticsearch)]
        MQ[RabbitMQ]
    end
    GW --> AUTH & CAT & CART & ORD & PAY & PICK & DEL & ADMIN
    ORD & PAY & DISP -.->|events| MQ
    AUTH & CAT & PAY & PICK & DEL --> PG
    CAT --> RD & ES
    INV --> L & M & G & V & SB & YE & KM & AL
    PAY --> TB & SBP
    NOTIF --> SMS & FCM

{
  "event_name": "product_clicked",
  "timestamp": "2026-06-17T10:00:00Z",
  "user_id": "uuid",
  "session_id": "uuid",
  "device_type": "web",
  "properties": {
    "product_id": "12345",
    "price": 499.90,
    "position": 3,
    "source": "search_results"
  }
}

{
  "error": {
    "code": "ORDER_NOT_FOUND",
    "message": "Заказ с указанным ID не найден",
    "details": { "order_id": "12345" },
    "request_id": "req_abc123"
  }
}

stateDiagram-v2
    [*] --> pending
    pending --> paid: payment.succeeded
    pending --> cancelled: User cancels
    paid --> picking: Dispatcher assigns picker
    paid --> cancelled: User cancels
    picking --> packed: Picker confirms
    picking --> cancelled: Admin cancels
    packed --> in_transit: Courier picks up
    in_transit --> delivered: Courier confirms
    in_transit --> cancelled: Delivery failed
    delivered --> refunded: Return requested
    cancelled --> [*]
    refunded --> [*]

stateDiagram-v2
    [*] --> pending
    pending --> processing: User submits payment
    processing --> succeeded: Bank webhook success
    processing --> failed: Bank webhook decline
    failed --> processing: User retries
    succeeded --> refunded: Admin initiates refund
    refunded --> [*]

stateDiagram-v2
    [*] --> pending
    pending --> assigned: Dispatcher assigns courier
    assigned --> picking_up: Courier at store
    picking_up --> in_transit: Package loaded
    in_transit --> delivered: POD captured
    in_transit --> failed: Timeout / unavailable
    failed --> returned: Return to store
    returned --> [*]
    delivered --> [*]

stateDiagram-v2
    [*] --> offline
    offline --> free: Comes online
    free --> busy: Delivery assigned
    busy --> free: Delivery completed
    free --> on_break: Starts break
    on_break --> free: Break ends
    free --> offline: Goes offline
    busy --> offline: Shift ends
    busy --> on_break: Break allowed

stateDiagram-v2
    [*] --> assigned
    assigned --> started: Picker opens task
    started --> substituted: Item missing, alternative found
    substituted --> packed: All processed
    started --> packed: All found
    packed --> handed_over: Courier receives
    handed_over --> [*]

sequenceDiagram
    actor C as Клиент
    participant GW as API Gateway
    participant Cart as Cart Service
    participant Ord as Order Service
    participant Pay as Payment Service
    participant TB as Т-Банк
    participant Notif as Notification

    C->>GW: Добавить товары в корзину
    GW->>Cart: POST /cart/update_items
    Cart-->>GW: Корзина обновлена
    GW-->>C: Товары в корзине
    C->>GW: Оформить заказ
    GW->>Ord: POST /orders
    Ord->>Cart: Получить корзину
    Cart-->>Ord: Данные корзины
    Ord->>Ord: Создать заказ (pending)
    Ord-->>GW: order_id, total
    GW-->>C: Заказ создан
    C->>GW: Оплатить
    GW->>Pay: POST /payments/init
    Pay->>TB: Создать платёж
    TB-->>Pay: payment_url
    Pay-->>GW: payment_url
    GW-->>C: Перенаправление на оплату
    C->>TB: Ввести данные карты
    TB-->>C: 3DSecure / успех
    TB->>Pay: Webhook: succeeded
    Pay->>Ord: order.paid
    Ord->>Ord: Статус → paid
    Pay->>Notif: Уведомление клиенту
    Notif-->>C: Заказ оплачен

sequenceDiagram
    actor P as Пикер
    participant PickSvc as Picker Service
    participant Ord as Order Service
    participant Inv as Inventory
    actor C as Клиент

    P->>PickSvc: Начать сборку
    PickSvc->>Ord: order.picking_started
    loop Каждый товар
        P->>PickSvc: Сканировать товар
        PickSvc->>Inv: Проверить остаток
        alt Товар в наличии
            Inv-->>PickSvc: В наличии
            PickSvc-->>P: Подтверждён
        else Нет в наличии
            Inv-->>PickSvc: Отсутствует
            PickSvc-->>P: Нет в наличии
            P->>C: Звонок: предложить замену
            alt Клиент согласен
                C-->>P: Да, замените
                P->>PickSvc: Выбрать замену
            else Клиент отказывается
                C-->>P: Нет, удалите
                P->>PickSvc: Пропустить товар
            end
        end
    end
    P->>PickSvc: Завершить сборку
    PickSvc->>Ord: order.picking_completed

sequenceDiagram
    participant Disp as Dispatcher
    participant OSRM
    participant RD as Redis GEO
    participant Cou as Courier App
    participant Notif as Notification

    Note over Disp: Заказ собран (order.picking_completed)
    Disp->>RD: GEORADIUS(store_location)
    RD-->>Disp: Ближайшие курьеры
    Disp->>Disp: Cheapest Insertion Heuristic
    Disp->>OSRM: Маршрут от курьера до клиента
    OSRM-->>Disp: ETA, distance
    Disp->>Disp: Назначить курьера
    Disp->>Cou: POST /courier/assign
    Cou-->>Disp: Принято
    Disp->>Notif: order.assigned
    Note over Disp: Courier: busy, ETA рассчитан

sequenceDiagram
    actor C as Клиент
    participant Ord as Order Service
    participant Pay as Payment Service
    participant TB as Т-Банк
    participant Inv as Inventory
    participant Notif as Notification

    C->>Ord: Запросить возврат
    Ord->>Ord: Проверить статус заказа
    alt Заказ ещё не доставлен
        Ord->>Ord: Отмена заказа
        Ord->>Pay: Инициировать refund
    else Заказ доставлен
        Ord->>Ord: Создать возврат (refunded)
        Ord->>Pay: Инициировать refund
    end
    Pay->>TB: POST /refund
    TB-->>Pay: Refund успешен
    Pay->>Ord: payment.refunded
    Ord->>Inv: Вернуть остатки
    Ord->>Notif: Уведомить клиента
    Notif-->>C: Возврат оформлен

sequenceDiagram
    actor K as Курьер
    participant App as Courier App
    participant Hive as Hive (offline)
    participant API as Courier API

    Note over K,API: Онлайн-режим
    K->>App: Получить задание
    App->>API: GET /orders/active
    API-->>App: Данные заказа
    App-->>K: Заказ загружен
    Note over K,API: Потеря интернета
    K->>App: Отметить доставку
    App->>Hive: Сохранить событие (pending)
    Hive-->>App: Сохранено
    App-->>K: Доставка отмечена (офлайн)
    Note over K,API: Интернет восстановлен
    App->>App: SyncQueue: отправить накопленные события
    App->>API: POST /orders/sync (batch)
    API-->>App: Подтверждение
    App->>Hive: Удалить синхронизированные
    App-->>K: Данные синхронизированы

{
  "event_id": "uuid-v4",
  "event_type": "order.created",
  "occurred_at": "2026-06-17T10:00:00Z",
  "aggregate_id": "order_12345",
  "aggregate_type": "order",
  "payload": { ... },
  "metadata": {
    "correlation_id": "uuid",
    "causation_id": "uuid",
    "user_id": "user_67890",
    "source": "order-service",
    "schema_version": "1.0"
  }
}

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "required": ["order_id", "user_id", "store_id", "total", "items", "delivery_slot"],
  "properties": {
    "order_id": { "type": "string", "pattern": "^order_\\d+$" },
    "user_id": { "type": "string", "pattern": "^user_\\d+$" },
    "store_id": { "type": "string", "pattern": "^store_\\d+$" },
    "total": { "type": "number", "minimum": 0, "multipleOf": 0.01 },
    "delivery_fee": { "type": "number", "minimum": 0 },
    "items": {
      "type": "array",
      "minItems": 1,
      "items": {
        "type": "object",
        "required": ["product_id", "quantity", "price"],
        "properties": {
          "product_id": { "type": "string" },
          "quantity": { "type": "integer", "minimum": 1 },
          "price": { "type": "number", "minimum": 0 }
        }
      }
    },
    "delivery_slot": {
      "type": "object",
      "required": ["start", "end"],
      "properties": {
        "start": { "type": "string", "format": "date-time" },
        "end": { "type": "string", "format": "date-time" }
      }
    },
    "payment_method": { "type": "string", "enum": ["card", "sbp", "cash", "card_courier"] }
  }
}

{
  "order_id": "order_12345",
  "user_id": "user_67890",
  "store_id": "store_42",
  "total": 1850.50,
  "delivery_fee": 99.00,
  "items": [
    {"product_id": "prod_1001", "quantity": 2, "price": 450.00},
    {"product_id": "prod_1002", "quantity": 1, "price": 350.50}
  ],
  "delivery_slot": {"start": "2026-06-17T18:00:00Z", "end": "2026-06-17T20:00:00Z"},
  "payment_method": "card"
}

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "required": ["order_id", "payment_id", "amount", "method"],
  "properties": {
    "order_id": { "type": "string" },
    "payment_id": { "type": "string" },
    "amount": { "type": "number", "minimum": 0 },
    "method": { "type": "string", "enum": ["card", "sbp", "cash", "card_courier"] },
    "provider": { "type": "string", "enum": ["t-bank", "sbp"] },
    "paid_at": { "type": "string", "format": "date-time" }
  }
}

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "required": ["order_id", "picker_id", "courier_id", "eta"],
  "properties": {
    "order_id": { "type": "string" },
    "picker_id": { "type": "string" },
    "courier_id": { "type": "string" },
    "eta": {
      "type": "object",
      "required": ["delivery_min", "distance_km"],
      "properties": {
        "delivery_min": { "type": "integer", "minimum": 1 },
        "distance_km": { "type": "number", "minimum": 0 }
      }
    }
  }
}

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "required": ["order_id", "picker_id", "started_at"],
  "properties": {
    "order_id": { "type": "string" },
    "picker_id": { "type": "string" },
    "started_at": { "type": "string", "format": "date-time" }
  }
}

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "required": ["order_id", "picker_id", "items_found", "items_substituted"],
  "properties": {
    "order_id": { "type": "string" },
    "picker_id": { "type": "string" },
    "packed_at": { "type": "string", "format": "date-time" },
    "items_found": { "type": "integer", "minimum": 0 },
    "items_substituted": { "type": "integer", "minimum": 0 },
    "substitutions": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "original_product_id": { "type": "string" },
          "substitute_product_id": { "type": "string" },
          "customer_approved": { "type": "boolean" }
        }
      }
    }
  }
}

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "required": ["order_id", "courier_id", "eta"],
  "properties": {
    "order_id": { "type": "string" },
    "courier_id": { "type": "string" },
    "eta": {
      "type": "object",
      "required": ["delivery_min", "distance_km"],
      "properties": {
        "delivery_min": { "type": "integer", "minimum": 1 },
        "distance_km": { "type": "number", "minimum": 0 }
      }
    },
    "route": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "lat": { "type": "number" },
          "lng": { "type": "number" },
          "timestamp": { "type": "string", "format": "date-time" }
        }
      }
    }
  }
}

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "required": ["order_id", "courier_id", "delivered_at"],
  "properties": {
    "order_id": { "type": "string" },
    "courier_id": { "type": "string" },
    "delivered_at": { "type": "string", "format": "date-time" },
    "pod_signature": { "type": "string", "description": "Base64-encoded signature image" },
    "pod_photo": { "type": "string", "description": "URL to delivery photo" },
    "payment_collected": { "type": "number", "description": "Amount collected on delivery" }
  }
}

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "required": ["order_id", "reason", "cancelled_at"],
  "properties": {
    "order_id": { "type": "string" },
    "reason": { "type": "string", "enum": ["user_cancelled", "admin_cancelled", "delivery_failed", "payment_failed", "timeout"] },
    "cancelled_at": { "type": "string", "format": "date-time" },
    "refund_amount": { "type": "number", "minimum": 0 },
    "refund_status": { "type": "string", "enum": ["pending", "processed", "none"] }
  }
}

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "required": ["order_id", "refund_id", "amount", "refunded_at"],
  "properties": {
    "order_id": { "type": "string" },
    "refund_id": { "type": "string" },
    "amount": { "type": "number", "minimum": 0 },
    "refunded_at": { "type": "string", "format": "date-time" },
    "reason": { "type": "string" }
  }
}

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "required": ["store_id", "product_id", "quantity"],
  "properties": {
    "store_id": { "type": "string" },
    "product_id": { "type": "string" },
    "quantity": { "type": "integer", "minimum": 0 },
    "threshold": { "type": "integer", "minimum": 1 }
  }
}

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "required": ["chain_id", "synced_at"],
  "properties": {
    "chain_id": { "type": "string" },
    "synced_at": { "type": "string", "format": "date-time" },
    "products_count": { "type": "integer", "minimum": 0 },
    "categories_count": { "type": "integer", "minimum": 0 },
    "errors": { "type": "array", "items": { "type": "string" } },
    "duration_seconds": { "type": "integer", "minimum": 0 }
  }
}

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "required": ["zone_id", "cycle_id", "orders"],
  "properties": {
    "zone_id": { "type": "string" },
    "cycle_id": { "type": "string" },
    "orders": {
      "type": "array",
      "items": {
        "type": "object",
        "required": ["order_id", "store_id", "destination"],
        "properties": {
          "order_id": { "type": "string" },
          "store_id": { "type": "string" },
          "destination": {
            "type": "object",
            "properties": {
              "lat": { "type": "number" },
              "lng": { "type": "number" },
              "address": { "type": "string" }
            }
          },
          "weight_kg": { "type": "number", "maximum": 80 }
        }
      }
    },
    "available_couriers": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "courier_id": { "type": "string" },
          "current_location": { "type": "object", "properties": { "lat": { "type": "number" }, "lng": { "type": "number" } } },
          "status": { "type": "string", "enum": ["free", "busy"] }
        }
      }
    }
  }
}

class IdempotencyMiddleware
  def initialize(app, redis = Redis.new)
    @app = app
    @redis = redis
  end

  def call(env)
    key = env['HTTP_IDEMPOTENCY_KEY']
    user_id = env['HTTP_X_USER_ID']
    cache_key = "idempotency:#{user_id}:#{key}"

    if key && user_id
      cached = @redis.get(cache_key)
      if cached
        data = JSON.parse(cached)
        return [data['status'], data['headers'], [data['body']]]
      end

      status, headers, body = @app.call(env)
      @redis.setex(cache_key, 86_400, {status: status, headers: headers, body: body.join}.to_json)
      [status, headers, body]
    else
      @app.call(env)
    end
  end
end

type cachedResponse struct {
    Status  int    `json:"status"`
    Headers map[string]string `json:"headers,omitempty"`
    Body    string `json:"body"`
}

func IdempotencyMiddleware(rdb *redis.Client) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            key := r.Header.Get("Idempotency-Key")
            userID := r.Header.Get("X-User-Id")
            if key == "" || userID == "" {
                next.ServeHTTP(w, r)
                return
            }

            ctx := r.Context()
            cacheKey := fmt.Sprintf("idempotency:%s:%s", userID, key)
            if cached, err := rdb.Get(ctx, cacheKey).Result(); err == nil {
                var resp cachedResponse
                json.Unmarshal([]byte(cached), &resp)
                for k, v := range resp.Headers {
                    w.Header().Set(k, v)
                }
                w.WriteHeader(resp.Status)
                w.Write([]byte(resp.Body))
                return
            }

            recorder := &statusRecorder{ResponseWriter: w, status: 200}
            next.ServeHTTP(recorder, r)

            data, _ := json.Marshal(cachedResponse{
                Status: recorder.status,
                Headers: recorder.Header(),
                Body:   recorder.body.String(),
            })
            rdb.Set(ctx, cacheKey, data, 24*time.Hour)
        })
    }
}

graph LR
    subgraph "Этапы миграции"
        A[Monolith] -->|Double Write| B[Double Write]
        B -->|Validation| C[Validation]
        C -->|Cut-over| D[Microservice]
        D -.->|7 days read-only| A
    end

graph TB
    subgraph "Порядок миграции"
        M1[1. Catalog] --> M2[2. User & Auth]
        M2 --> M3[3. Inventory]
        M3 --> M4[4. Order + Payment]
        M4 --> M5[5. Delivery + Dispatcher]
        M5 --> M6[6. Notification, Analytics]
    end
    style M1 fill:#90EE90
    style M2 fill:#90EE90
    style M3 fill:#FFD700
    style M4 fill:#FF4444
    style M5 fill:#FFD700
    style M6 fill:#90EE90

sequenceDiagram
    participant Svc as Service
    participant Old as Old DB (Monolith)
    participant New as New DB (Microservice)
    participant Outbox as Transactional Outbox
    participant Recon as Reconciliation Job

    Svc->>Old: Запись в старую БД
    Svc->>New: Запись в новую БД
    Svc->>Outbox: Сохранить событие
    Outbox->>Outbox: await delivery
    Recon->>Old: SELECT COUNT, SUM
    Recon->>New: SELECT COUNT, SUM
    alt Расхождение > 0.1%
        Recon->>Alert: PagerDuty/Slack
    else Расхождение > 1%
        Recon->>Block: Блокировка cut-over
    end