from datetime import datetime
from sqlalchemy import Column, Integer, String, Text, DateTime, ForeignKey, Index, Boolean, JSON, Float, Numeric, Enum
from sqlalchemy.orm import relationship
from app.db.base import Base


class Tenant(Base):
    __tablename__ = "tenants"
    
    id = Column(Integer, primary_key=True, index=True)
    name = Column(String(255), nullable=False)
    industry = Column(String(100), nullable=True)  # medicine, beauty, autoservice, delivery, education
    status = Column(String(50), default="active")
    created_at = Column(DateTime, default=datetime.utcnow)
    
    users = relationship("User", back_populates="tenant")
    customers = relationship("Customer", back_populates="tenant")
    templates = relationship("Template", back_populates="tenant")
    notifications = relationship("Notification", back_populates="tenant")


class User(Base):
    __tablename__ = "users"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False)
    email = Column(String(255), unique=True, index=True, nullable=False)
    password_hash = Column(String(255))
    role = Column(String(50), default="user")
    created_at = Column(DateTime, default=datetime.utcnow)
    
    tenant = relationship("Tenant", back_populates="users")
    api_keys = relationship("ApiKey", back_populates="user")


class ApiKey(Base):
    __tablename__ = "api_keys"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False)
    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
    name = Column(String(255), nullable=False)
    key_hash = Column(String(255), nullable=False, index=True)
    scopes = Column(JSON, default=list)
    created_at = Column(DateTime, default=datetime.utcnow)
    expires_at = Column(DateTime, nullable=True)
    
    user = relationship("User", back_populates="api_keys")


class Customer(Base):
    __tablename__ = "customers"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False)
    phone = Column(String(50), nullable=True)
    email = Column(String(255), nullable=True)
    tg_chat_id = Column(String(100), nullable=True)
    vk_user_id = Column(String(100), nullable=True)
    max_user_id = Column(String(100), nullable=True)  # Messenger Max user ID
    opt_out = Column(Boolean, default=False)  # Opt-out flag for notifications
    tags = Column(JSON, default=list)
    meta = Column(JSON, default=dict)
    created_at = Column(DateTime, default=datetime.utcnow)
    
    tenant = relationship("Tenant", back_populates="customers")
    
    __table_args__ = (
        Index("idx_customer_tenant_email", "tenant_id", "email"),
        Index("idx_customer_tenant_phone", "tenant_id", "phone"),
    )


class Template(Base):
    __tablename__ = "templates"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False)
    name = Column(String(255), nullable=False)
    slug = Column(String(255), nullable=False, index=True)
    channel_strategy = Column(JSON, default=dict)  # {"primary": ["telegram", "email"], "failover": true}
    # channel_config временно закомментировано до создания миграции БД
    # channel_config = Column(JSON, default=dict, nullable=True)  # {"email_config_id": 1, "telegram_bot_id": 2, "vk_group_id": 3}
    content = Column(Text, nullable=False)
    variables = Column(JSON, default=list)  # ["customer_name", "order_id"]
    created_at = Column(DateTime, default=datetime.utcnow)
    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    
    tenant = relationship("Tenant", back_populates="templates")
    notifications = relationship("Notification", back_populates="template")


class Segment(Base):
    __tablename__ = "segments"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False)
    name = Column(String(255), nullable=False)
    filter = Column(JSON, default=dict)  # {"tags": ["vip"], "created_after": "2024-01-01"}
    created_at = Column(DateTime, default=datetime.utcnow)


class Notification(Base):
    __tablename__ = "notifications"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False)
    template_id = Column(Integer, ForeignKey("templates.id"), nullable=False)
    segment_id = Column(Integer, nullable=True)
    customer_id = Column(Integer, ForeignKey("customers.id"), nullable=True)
    payload = Column(JSON, default=dict)
    scheduled_at = Column(DateTime, nullable=True)
    status = Column(String(50), default="pending")
    idempotency_key = Column(String(255), unique=True, nullable=True, index=True)
    created_at = Column(DateTime, default=datetime.utcnow)
    
    tenant = relationship("Tenant", back_populates="notifications")
    template = relationship("Template", back_populates="notifications")
    deliveries = relationship("Delivery", back_populates="notification")


class Delivery(Base):
    __tablename__ = "deliveries"
    
    id = Column(Integer, primary_key=True, index=True)
    notification_id = Column(Integer, ForeignKey("notifications.id"), nullable=False)
    channel = Column(String(50), nullable=False)
    target = Column(String(255), nullable=False)
    status = Column(String(50), default="pending")
    attempts = Column(Integer, default=0)
    last_error = Column(Text, nullable=True)
    sent_at = Column(DateTime, nullable=True)
    opened_at = Column(DateTime, nullable=True)
    clicked_at = Column(DateTime, nullable=True)
    response_meta = Column(JSON, default=dict)
    
    notification = relationship("Notification", back_populates="deliveries")
    
    __table_args__ = (
        Index("idx_delivery_notification", "notification_id"),
        Index("idx_delivery_status", "status"),
        Index("idx_delivery_opened_at", "opened_at"),
        Index("idx_delivery_clicked_at", "clicked_at"),
    )


class Webhook(Base):
    __tablename__ = "webhooks"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False)
    url = Column(String(500), nullable=False)
    secret = Column(String(255), nullable=False)
    events = Column(JSON, default=list)
    is_active = Column(Boolean, default=True)
    last_triggered = Column(DateTime, nullable=True)
    success_count = Column(Integer, default=0)
    failure_count = Column(Integer, default=0)
    created_at = Column(DateTime, default=datetime.utcnow)


class WebhookEvent(Base):
    __tablename__ = "webhook_events"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False)
    webhook_id = Column(Integer, ForeignKey("webhooks.id"), nullable=False)
    type = Column(String(100), nullable=False)
    payload = Column(JSON, default=dict)
    delivered_at = Column(DateTime, nullable=True)
    attempts = Column(Integer, default=0)


class EmailConfig(Base):
    __tablename__ = "email_configs"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False)
    name = Column(String(255), nullable=False)
    smtp_host = Column(String(255), nullable=False)
    smtp_port = Column(Integer, nullable=False)
    smtp_user = Column(String(255), nullable=True)
    smtp_password = Column(String(255), nullable=True)
    from_email = Column(String(255), nullable=False)
    from_name = Column(String(255), nullable=True)
    use_tls = Column(Boolean, default=True)
    is_default = Column(Boolean, default=False)
    created_at = Column(DateTime, default=datetime.utcnow)
    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)


class CustomField(Base):
    __tablename__ = "custom_fields"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False)
    name = Column(String(255), nullable=False)
    label = Column(String(255), nullable=False)
    type = Column(String(50), nullable=False)  # text, number, date, select, boolean
    options = Column(JSON, default=list)  # Для типа 'select'
    required = Column(Boolean, default=False)
    created_at = Column(DateTime, default=datetime.utcnow)
    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    
    __table_args__ = (
        Index("idx_custom_field_tenant_name", "tenant_id", "name"),
    )


class DLQ(Base):
    __tablename__ = "dlq"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False)
    notification_id = Column(Integer, ForeignKey("notifications.id"), nullable=False)
    channel = Column(String(50), nullable=False)
    reason = Column(Text, nullable=False)
    payload = Column(JSON, default=dict)
    created_at = Column(DateTime, default=datetime.utcnow)


class Plan(Base):
    """Тарифные планы"""
    __tablename__ = "plans"
    
    id = Column(Integer, primary_key=True, index=True)
    name = Column(String(100), nullable=False, unique=True)
    description = Column(Text)
    monthly_price = Column(Numeric(10, 2), nullable=False)
    notifications_limit = Column(Integer, nullable=False)  # Лимит уведомлений в месяц
    features = Column(JSON, default=dict)  # Дополнительные возможности
    is_active = Column(Boolean, default=True)
    created_at = Column(DateTime, default=datetime.utcnow)
    
    subscriptions = relationship("Subscription", back_populates="plan")


class Subscription(Base):
    """Подписки тенантов на тарифные планы"""
    __tablename__ = "subscriptions"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False)
    plan_id = Column(Integer, ForeignKey("plans.id"), nullable=False)
    status = Column(String(50), default="pending_payment")  # pending_payment, active, cancelled, expired
    started_at = Column(DateTime, default=datetime.utcnow)
    expires_at = Column(DateTime, nullable=True)
    auto_renew = Column(Boolean, default=True)
    created_at = Column(DateTime, default=datetime.utcnow)
    
    plan = relationship("Plan", back_populates="subscriptions")
    usage_records = relationship("UsageRecord", back_populates="subscription")
    payments = relationship("Payment", back_populates="subscription")


class UsageRecord(Base):
    """Записи об использовании (сколько уведомлений отправлено)"""
    __tablename__ = "usage_records"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False)
    subscription_id = Column(Integer, ForeignKey("subscriptions.id"), nullable=False)
    period_start = Column(DateTime, nullable=False)
    period_end = Column(DateTime, nullable=False)
    notifications_sent = Column(Integer, default=0)
    notifications_limit = Column(Integer, nullable=False)
    created_at = Column(DateTime, default=datetime.utcnow)
    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    
    subscription = relationship("Subscription", back_populates="usage_records")


class Payment(Base):
    """История платежей"""
    __tablename__ = "payments"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False)
    subscription_id = Column(Integer, ForeignKey("subscriptions.id"), nullable=False)
    amount = Column(Numeric(10, 2), nullable=False)
    currency = Column(String(3), default="USD")
    status = Column(String(50), default="pending")  # pending, completed, failed, refunded
    payment_method = Column(String(50))  # card, bank_transfer, etc
    transaction_id = Column(String(255), unique=True, index=True)
    payment_metadata = Column(JSON, default=dict)
    created_at = Column(DateTime, default=datetime.utcnow)
    completed_at = Column(DateTime, nullable=True)
    
    subscription = relationship("Subscription", back_populates="payments")


class LimitAlert(Base):
    """Уведомления о превышении лимитов"""
    __tablename__ = "limit_alerts"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False)
    alert_type = Column(String(50), nullable=False)  # warning, critical, exceeded
    threshold = Column(Integer, nullable=False)  # Процент использования (80, 90, 100)
    current_usage = Column(Integer, nullable=False)
    limit_value = Column(Integer, nullable=False)
    message = Column(Text)
    is_sent = Column(Boolean, default=False)
    created_at = Column(DateTime, default=datetime.utcnow)
    sent_at = Column(DateTime, nullable=True)


class UserBalance(Base):
    """Баланс пользователя"""
    __tablename__ = "user_balances"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False, unique=True)
    balance = Column(Numeric(10, 2), default=0, nullable=False)  # Текущий баланс в рублях
    total_deposited = Column(Numeric(10, 2), default=0, nullable=False)  # Общая сумма пополнений
    total_spent = Column(Numeric(10, 2), default=0, nullable=False)  # Общая сумма потрачено
    created_at = Column(DateTime, default=datetime.utcnow)
    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    
    # Связи
    tenant = relationship("Tenant", backref="balance")


class BalanceTransaction(Base):
    """Транзакции по балансу"""
    __tablename__ = "balance_transactions"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False)
    transaction_type = Column(String(20), nullable=False)  # deposit, withdraw, subscription_payment
    amount = Column(Numeric(10, 2), nullable=False)  # Сумма (положительная для пополнения, отрицательная для списания)
    balance_before = Column(Numeric(10, 2), nullable=False)  # Баланс до транзакции
    balance_after = Column(Numeric(10, 2), nullable=False)  # Баланс после транзакции
    description = Column(String(255))  # Описание транзакции
    reference_id = Column(String(255))  # ID связанной записи (например, subscription_id)
    created_at = Column(DateTime, default=datetime.utcnow)
    
    # Связи
    tenant = relationship("Tenant")


class Integration(Base):
    """Интеграции с внешними системами (CRM, etc)"""
    __tablename__ = "integrations"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False)
    type = Column(String(50), nullable=False)  # amocrm, bitrix24, 1c, custom
    name = Column(String(255), nullable=False)
    config = Column(JSON, default=dict)  # API credentials, URLs, etc
    status = Column(String(50), default="pending")  # pending, connected, error, disconnected
    last_sync_at = Column(DateTime, nullable=True)
    last_error = Column(Text, nullable=True)
    error_type = Column(String(50), nullable=True)  # Тип ошибки для лучшего UX
    error_timestamp = Column(DateTime, nullable=True)  # Время последней ошибки
    sync_stats = Column(JSON, default=dict)  # {"customers_synced": 100, "errors": 5}
    is_active = Column(Boolean, default=True)
    created_at = Column(DateTime, default=datetime.utcnow)
    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    
    # Связи
    sync_logs = relationship("IntegrationSyncLog", back_populates="integration")
    
    __table_args__ = (
        Index("idx_integration_tenant", "tenant_id"),
        Index("idx_integration_type", "type"),
        Index("idx_integration_status", "status"),
    )


class IntegrationSyncLog(Base):
    """Журнал синхронизации с CRM"""
    __tablename__ = "integration_sync_logs"
    
    id = Column(Integer, primary_key=True, index=True)
    integration_id = Column(Integer, ForeignKey("integrations.id"), nullable=False)
    sync_type = Column(String(50), nullable=False)  # customers, contacts, leads
    status = Column(String(50), nullable=False)  # in_progress, success, failed
    records_processed = Column(Integer, default=0)
    records_created = Column(Integer, default=0)
    records_updated = Column(Integer, default=0)
    records_failed = Column(Integer, default=0)
    error_message = Column(Text, nullable=True)
    started_at = Column(DateTime, default=datetime.utcnow)
    completed_at = Column(DateTime, nullable=True)
    sync_metadata = Column(JSON, default=dict)
    
    # Связи
    integration = relationship("Integration", back_populates="sync_logs")
    
    __table_args__ = (
        Index("idx_sync_log_integration", "integration_id"),
        Index("idx_sync_log_status", "status"),
    )


class CRMFieldMapping(Base):
    """Сопоставление полей CRM с полями системы"""
    __tablename__ = "crm_field_mappings"
    
    id = Column(Integer, primary_key=True, index=True)
    integration_id = Column(Integer, ForeignKey("integrations.id"), nullable=False)
    
    # Сопоставление полей
    field_mappings = Column(JSON, default=dict)  # {"customer_name": "contact.NAME", "phone": "contact.PHONE"}
    
    # Дополнительные настройки
    webhook_events = Column(JSON, default=list)  # ["onCrmDealAdd", "onCrmDealUpdate"]
    automation_rules = Column(JSON, default=dict)  # {"appointment.created": {"template_id": 1}}
    
    created_at = Column(DateTime, default=datetime.utcnow)
    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    
    __table_args__ = (
        Index("idx_crm_mapping_integration", "integration_id"),
    )


class IndustryTemplate(Base):
    """Готовые шаблоны для разных индустрий"""
    __tablename__ = "industry_templates"
    
    id = Column(Integer, primary_key=True, index=True)
    industry = Column(String(50), nullable=False)  # medicine, beauty, autoservice, delivery, education
    key = Column(String(100), nullable=False, unique=True)  # appointment-reminder-24h
    name = Column(String(255), nullable=False)
    description = Column(Text, nullable=True)
    trigger_type = Column(String(100), nullable=False)  # appointment.created, order.completed
    delay_hours = Column(Integer, default=0)  # Задержка перед отправкой (0 = сразу, 24 = за сутки)
    content = Column(JSON, default=dict)  # {"telegram": "text", "email": "text"}
    variables = Column(JSON, default=list)  # ["customer_name", "appointment_date"]
    channels = Column(JSON, default=list)  # ["telegram", "email"]
    is_active_by_default = Column(Boolean, default=True)
    is_editable = Column(Boolean, default=True)
    created_at = Column(DateTime, default=datetime.utcnow)
    
    __table_args__ = (
        Index("idx_industry_template_industry", "industry"),
        Index("idx_industry_template_trigger", "trigger_type"),
    )


class UserIndustryTemplate(Base):
    """Копия отраслевого шаблона для конкретного пользователя"""
    __tablename__ = "user_industry_templates"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False)
    industry_template_id = Column(Integer, ForeignKey("industry_templates.id"), nullable=False)
    template_id = Column(Integer, ForeignKey("templates.id"), nullable=True)  # Связь с обычным шаблоном
    
    # Кастомизация
    custom_name = Column(String(255), nullable=True)
    custom_content = Column(JSON, nullable=True)  # Переопределенный контент
    custom_delay_hours = Column(Integer, nullable=True)
    
    # Настройки
    is_active = Column(Boolean, default=True)
    channels = Column(JSON, default=list)  # Какие каналы использовать
    is_custom = Column(Boolean, default=False)  # Кастомный шаблон или из пакета
    
    created_at = Column(DateTime, default=datetime.utcnow)
    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    
    __table_args__ = (
        Index("idx_user_template_tenant", "tenant_id"),
        Index("idx_user_template_industry", "industry_template_id"),
        Index("idx_user_template_active", "is_active"),
    )


class CustomTrigger(Base):
    """Кастомные триггеры для пользователей"""
    __tablename__ = "custom_triggers"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False)
    name = Column(String(255), nullable=False)  # "appointment.created"
    display_name = Column(String(255), nullable=False)  # "При создании записи"
    description = Column(Text, nullable=True)  # "Срабатывает когда..."
    category = Column(String(100), nullable=True)  # "appointment", "order", "booking"
    is_active = Column(Boolean, default=True)
    created_at = Column(DateTime, default=datetime.utcnow)
    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    
    __table_args__ = (
        Index("idx_custom_trigger_tenant", "tenant_id"),
        Index("idx_custom_trigger_name", "name"),
        Index("idx_custom_trigger_category", "category"),
    )


class ScheduledNotification(Base):
    """Запланированные уведомления для отправки в будущем"""
    __tablename__ = "scheduled_notifications"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False)
    customer_id = Column(Integer, ForeignKey("customers.id"), nullable=False)
    template_id = Column(Integer, ForeignKey("templates.id"), nullable=True)
    user_template_id = Column(Integer, ForeignKey("user_industry_templates.id"), nullable=True)
    
    # Когда отправлять
    scheduled_at = Column(DateTime, nullable=False)
    
    # Данные для отправки
    payload = Column(JSON, default=dict)
    channels = Column(JSON, default=list)
    
    # Статус
    status = Column(String(50), default="pending")  # pending, sent, failed, cancelled
    notification_id = Column(Integer, ForeignKey("notifications.id"), nullable=True)  # После отправки
    
    # Метаданные
    trigger_type = Column(String(100), nullable=True)  # appointment.created
    external_id = Column(String(255), nullable=True)  # ID события из CRM
    
    created_at = Column(DateTime, default=datetime.utcnow)
    sent_at = Column(DateTime, nullable=True)
    
    __table_args__ = (
        Index("idx_scheduled_tenant", "tenant_id"),
        Index("idx_scheduled_time", "scheduled_at"),
        Index("idx_scheduled_status", "status"),
    )


class RecurringSchedule(Base):
    """Повторяющиеся расписания для автоматических рассылок"""
    __tablename__ = "recurring_schedules"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False)
    name = Column(String(255), nullable=False)
    
    # Шаблон и сегмент
    template_id = Column(Integer, ForeignKey("templates.id"), nullable=True)
    user_template_id = Column(Integer, ForeignKey("user_industry_templates.id"), nullable=True)
    segment_id = Column(Integer, nullable=True)  # ID сегмента клиентов (пока просто число)
    
    # Расписание
    cron_expression = Column(String(100), nullable=True)  # "0 10 * * 1" для cron
    schedule_type = Column(String(50), nullable=False)  # daily, weekly, monthly, cron
    schedule_config = Column(JSON, nullable=True)  # Дополнительные настройки расписания
    
    # Статус
    is_active = Column(Boolean, default=True)
    next_run_at = Column(DateTime, nullable=True)  # Следующий запуск
    last_run_at = Column(DateTime, nullable=True)  # Последний запуск
    
    # Статистика
    sent_count = Column(Integer, default=0)
    
    created_at = Column(DateTime, default=datetime.utcnow)
    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    
    __table_args__ = (
        Index("idx_recurring_schedule_tenant", "tenant_id"),
        Index("idx_recurring_schedule_active", "is_active"),
        Index("idx_recurring_schedule_next_run", "next_run_at"),
    )


class TelegramBot(Base):
    __tablename__ = "telegram_bots"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False, unique=True)
    bot_token_enc = Column(Text, nullable=False)  # Encrypted bot token
    username = Column(String(255), nullable=True)  # @bot_username
    webhook_secret = Column(String(255), nullable=True)  # Secret for webhook validation
    status = Column(String(50), default="active")  # active, disabled, error
    created_at = Column(DateTime, default=datetime.utcnow)
    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    
    tenant = relationship("Tenant", backref="telegram_bot")


class TelegramMtprotoAccount(Base):
    """MTProto аккаунты для отправки сообщений от разных номеров"""
    __tablename__ = "telegram_mtproto_accounts"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False)
    name = Column(String(255), nullable=False)  # Название аккаунта (например, "Основной номер")
    phone = Column(String(50), nullable=False)  # Номер телефона (+79991234567)
    api_id = Column(Integer, nullable=False)  # Telegram API ID
    api_hash_enc = Column(Text, nullable=False)  # Зашифрованный API Hash
    username = Column(String(255), nullable=True)  # Username аккаунта (@username)
    status = Column(String(50), default="active")  # active, disabled, error, pending_auth
    session_path = Column(String(500), nullable=True)  # Путь к файлу сессии
    is_default = Column(Boolean, default=False)  # Аккаунт по умолчанию для тенанта
    created_at = Column(DateTime, default=datetime.utcnow)
    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    
    tenant = relationship("Tenant", backref="telegram_mtproto_accounts")
    
    __table_args__ = (
        Index("idx_mtproto_tenant_status", "tenant_id", "status"),
        Index("idx_mtproto_tenant_default", "tenant_id", "is_default"),
    )


class VkGroup(Base):
    """VK группы для отправки уведомлений"""
    __tablename__ = "vk_groups"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False)
    name = Column(String(255), nullable=False)  # Название группы
    group_id = Column(String(100), nullable=False)  # ID группы VK
    access_token_enc = Column(Text, nullable=False)  # Зашифрованный access token
    status = Column(String(50), default="active")  # active, disabled, error
    created_at = Column(DateTime, default=datetime.utcnow)
    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    
    tenant = relationship("Tenant", backref="vk_groups")
    
    __table_args__ = (
        Index("idx_vk_group_tenant", "tenant_id"),
        Index("idx_vk_group_group_id", "group_id"),
    )


class TenantSettings(Base):
    __tablename__ = "tenant_settings"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False, unique=True)
    tg_sender = Column(String(50), default="system")  # system, brand, mtproto, disabled
    mtproto_account_id = Column(Integer, ForeignKey("telegram_mtproto_accounts.id"), nullable=True)  # MTProto аккаунт по умолчанию
    created_at = Column(DateTime, default=datetime.utcnow)
    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    
    tenant = relationship("Tenant", backref="settings")
    mtproto_account = relationship("TelegramMtprotoAccount", foreign_keys=[mtproto_account_id])


class CRMConnection(Base):
    """CRM подключения в режиме BYO-Keys"""
    __tablename__ = "crm_connections"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False)
    portal_url = Column(String(255), nullable=False)
    client_id = Column(String(255), nullable=False)
    client_secret = Column(String(255), nullable=False)
    access_token = Column(Text, nullable=True)
    refresh_token = Column(Text, nullable=True)
    expires_at = Column(DateTime, nullable=True)
    domain = Column(String(255), nullable=True)
    member_id = Column(String(255), nullable=True)
    status = Column(Enum('pending', 'connected', 'error', name='crm_connection_status'), nullable=False, default='pending')
    created_at = Column(DateTime, default=datetime.utcnow)
    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    
    tenant = relationship("Tenant", backref="crm_connections")
    
    __table_args__ = (
        Index("idx_crm_connections_tenant_id", "tenant_id"),
        Index("idx_crm_connections_status", "status"),
        Index("idx_crm_connections_domain", "domain"),
    )


class Rule(Base):
    """Правила с условиями для автоматических рассылок"""
    __tablename__ = "rules"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False)
    name = Column(String(255), nullable=False)
    
    # Шаблон, к которому применяется правило
    template_id = Column(Integer, ForeignKey("templates.id"), nullable=True)
    user_template_id = Column(Integer, ForeignKey("user_industry_templates.id"), nullable=True)
    
    # Условия в формате JSON
    conditions = Column(JSON, nullable=False)
    
    # Статус
    is_active = Column(Boolean, default=True)
    
    created_at = Column(DateTime, default=datetime.utcnow)
    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    
    tenant = relationship("Tenant", backref="rules")
    template = relationship("Template", backref="rules")
    user_template = relationship("UserIndustryTemplate", backref="rules")
    
    __table_args__ = (
        Index("idx_rule_tenant", "tenant_id"),
        Index("idx_rule_active", "is_active"),
    )


class Chain(Base):
    """Цепочки уведомлений (drip campaigns)"""
    __tablename__ = "chains"
    
    id = Column(Integer, primary_key=True, index=True)
    tenant_id = Column(Integer, ForeignKey("tenants.id"), nullable=False)
    name = Column(String(255), nullable=False)
    
    # Триггер запуска цепочки
    trigger_event = Column(String(255), nullable=False)  # customer.created, order.created, etc.
    
    # Статус
    is_active = Column(Boolean, default=True)
    
    # Статистика (можно вычислять из ChainExecution или хранить кеш)
    active_chains_count = Column(Integer, default=0)  # Активные экземпляры цепочки
    completed_chains_count = Column(Integer, default=0)  # Завершенные экземпляры
    
    created_at = Column(DateTime, default=datetime.utcnow)
    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    
    tenant = relationship("Tenant", backref="chains")
    steps = relationship("ChainStep", back_populates="chain", cascade="all, delete-orphan", order_by="ChainStep.order")
    
    __table_args__ = (
        Index("idx_chain_tenant", "tenant_id"),
        Index("idx_chain_active", "is_active"),
        Index("idx_chain_trigger", "trigger_event"),
    )


class ChainStep(Base):
    """Шаги цепочки уведомлений"""
    __tablename__ = "chain_steps"
    
    id = Column(Integer, primary_key=True, index=True)
    chain_id = Column(Integer, ForeignKey("chains.id"), nullable=False)
    
    # Порядок шага в цепочке
    order = Column(Integer, nullable=False)
    
    # Шаблон для этого шага
    template_id = Column(Integer, ForeignKey("templates.id"), nullable=True)
    user_template_id = Column(Integer, ForeignKey("user_industry_templates.id"), nullable=True)
    
    # Задержка перед отправкой (в минутах)
    delay_minutes = Column(Integer, default=0)
    
    created_at = Column(DateTime, default=datetime.utcnow)
    
    chain = relationship("Chain", back_populates="steps")
    template = relationship("Template", backref="chain_steps")
    user_template = relationship("UserIndustryTemplate", backref="chain_steps")
    
    __table_args__ = (
        Index("idx_chain_step_chain", "chain_id"),
        Index("idx_chain_step_order", "chain_id", "order"),
    )