import uuid
from datetime import datetime, timezone

from werkzeug.security import generate_password_hash, check_password_hash

from app import db


def utcnow():
    """Return naive UTC for compatibility with existing database values."""
    return datetime.now(timezone.utc).replace(tzinfo=None)


event_staff = db.Table(
    "event_staff",
    db.Column("event_id", db.Integer, db.ForeignKey("events.id", ondelete="CASCADE"), primary_key=True),
    db.Column("user_id", db.Integer, db.ForeignKey("users.id", ondelete="CASCADE"), primary_key=True),
)


class User(db.Model):
    __tablename__ = "users"

    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(100), unique=True, nullable=False)
    password_hash = db.Column(db.String(255), nullable=False)
    role = db.Column(db.String(20), nullable=False, default="staff")
    is_active = db.Column(db.Boolean, default=True, nullable=False)
    session_version = db.Column(db.Integer, default=0, nullable=False)
    created_at = db.Column(db.DateTime, default=utcnow, nullable=False)

    created_events = db.relationship("Event", backref="creator", lazy=True)

    def set_password(self, password):
        self.password_hash = generate_password_hash(password)
        self.session_version = (self.session_version or 0) + 1

    def check_password(self, password):
        return check_password_hash(self.password_hash, password)

    @property
    def is_admin(self):
        return self.role == "admin"

    @property
    def is_organizer(self):
        return self.role == "organizer"

    @property
    def is_staff(self):
        return self.role == "staff"

    def can_manage_event(self, event):
        if self.is_admin:
            return True
        if self.is_organizer and event and event.created_by_id == self.id:
            return True
        return False

    def __repr__(self):
        return f"<User {self.username} ({self.role})>"


class Event(db.Model):
    __tablename__ = "events"
    __table_args__ = (
        db.Index("ix_events_created_by_active", "created_by_id", "is_active"),
        db.Index("ix_events_event_date", "event_date"),
    )

    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(255), nullable=False)
    description = db.Column(db.Text, nullable=True)
    event_date = db.Column(db.DateTime, nullable=True)
    event_end_date = db.Column(db.DateTime, nullable=True)
    location = db.Column(db.String(255), nullable=True)
    is_active = db.Column(db.Boolean, default=True, nullable=False)
    created_by_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=True)
    created_at = db.Column(db.DateTime, default=utcnow, nullable=False)

    # Ticket design fields
    ticket_title = db.Column(db.String(255), nullable=True)
    ticket_subtitle = db.Column(db.String(255), nullable=True)
    ticket_body_text = db.Column(db.Text, nullable=True)
    ticket_background_color = db.Column(db.String(7), nullable=True, default="#ffffff")
    ticket_text_color = db.Column(db.String(7), nullable=True, default="#000000")
    ticket_accent_color = db.Column(db.String(7), nullable=True, default="#0d6efd")
    ticket_show_qr = db.Column(db.Boolean, default=True, nullable=False)
    ticket_show_photo = db.Column(db.Boolean, default=False, nullable=False)
    ticket_layout = db.Column(db.String(20), nullable=True, default="portrait")
    logo_filename = db.Column(db.String(255), nullable=True)
    rsvp_enabled = db.Column(db.Boolean, default=True, nullable=False)
    rsvp_deadline = db.Column(db.DateTime, nullable=True)
    invitation_subject = db.Column(db.String(255), nullable=True)
    invitation_message = db.Column(db.Text, nullable=True)

    guests = db.relationship("Guest", backref="event", lazy=True, cascade="all, delete-orphan")
    check_ins = db.relationship("CheckIn", backref="event", lazy=True, cascade="all, delete-orphan")
    staff_members = db.relationship(
        "User",
        secondary=event_staff,
        lazy="select",
        backref=db.backref("assigned_events", lazy="dynamic"),
    )

    def __repr__(self):
        return f"<Event {self.name}>"


class Guest(db.Model):
    __tablename__ = "guests"
    __table_args__ = (
        db.Index("ix_guests_event_full_name", "event_id", "full_name"),
        db.Index("ix_guests_event_email", "event_id", "email"),
        db.Index("ix_guests_event_active", "event_id", "is_active"),
        db.Index("ix_guests_event_rsvp", "event_id", "rsvp_status"),
    )

    id = db.Column(db.Integer, primary_key=True)
    event_id = db.Column(db.Integer, db.ForeignKey("events.id"), nullable=False)
    department = db.Column(db.String(255), nullable=False)
    last_name = db.Column(db.String(255), nullable=True)
    first_name = db.Column(db.String(255), nullable=True)
    middle_name = db.Column(db.String(255), nullable=True)
    full_name = db.Column(db.String(255), nullable=False)
    position = db.Column(db.String(255), nullable=True)
    email = db.Column(db.String(255), nullable=False)
    phone = db.Column(db.String(50), nullable=True)
    photo_filename = db.Column(db.String(255), nullable=True)
    token = db.Column(db.String(36), unique=True, nullable=False, default=lambda: str(uuid.uuid4()))
    qr_filename = db.Column(db.String(255), nullable=True)
    is_active = db.Column(db.Boolean, default=True, nullable=False)
    invitation_sent = db.Column(db.Boolean, default=False, nullable=False)
    invitation_status = db.Column(db.String(20), default="pending", nullable=False)
    invitation_attempts = db.Column(db.Integer, default=0, nullable=False)
    invitation_last_error = db.Column(db.String(1000), nullable=True)
    invitation_last_attempt_at = db.Column(db.DateTime, nullable=True)
    invitation_sent_at = db.Column(db.DateTime, nullable=True)
    rsvp_status = db.Column(db.String(20), default="pending", nullable=False)
    rsvp_responded_at = db.Column(db.DateTime, nullable=True)
    rsvp_comment = db.Column(db.String(1000), nullable=True)
    dietary_requirements = db.Column(db.String(1000), nullable=True)
    created_at = db.Column(db.DateTime, default=utcnow, nullable=False)
    updated_at = db.Column(db.DateTime, default=utcnow, onupdate=utcnow, nullable=False)

    check_ins = db.relationship("CheckIn", backref="guest", lazy=True, cascade="all, delete-orphan")

    @property
    def is_checked_in(self):
        return len(self.check_ins) > 0

    @property
    def last_check_in(self):
        if not self.check_ins:
            return None
        return max(check_in.checked_in_at for check_in in self.check_ins)

    def build_full_name(self):
        parts = [p for p in [self.last_name, self.first_name, self.middle_name] if p]
        return " ".join(parts) if parts else self.full_name

    def _photo_paths(self):
        """Возвращает путь к фото гостя в папке мероприятия."""
        if not self.photo_filename:
            return []
        from pathlib import Path
        from flask import current_app
        from app.utils.paths import event_photo_folder, safe_child_path
        if self.event_id:
            path = safe_child_path(event_photo_folder(self.event_id), self.photo_filename)
            return [path] if path else []
        # fallback только если мероприятие ещё не назначено
        path = safe_child_path(Path(current_app.config["PHOTO_FOLDER"]), self.photo_filename)
        return [path] if path else []

    @property
    def has_photo_file(self):
        try:
            return any(p.exists() for p in self._photo_paths())
        except Exception:
            return False

    @property
    def photo_url(self):
        if not self.has_photo_file:
            return ""
        from flask import url_for
        return url_for("main.guest_photo", guest_id=self.id)

    def __repr__(self):
        return f"<Guest {self.full_name} ({self.email})>"


class CheckIn(db.Model):
    __tablename__ = "check_ins"
    __table_args__ = (
        db.Index("ix_check_ins_event_time", "event_id", "checked_in_at"),
        db.UniqueConstraint("guest_id", name="uq_check_ins_guest_id"),
    )

    id = db.Column(db.Integer, primary_key=True)
    guest_id = db.Column(db.Integer, db.ForeignKey("guests.id"), nullable=False)
    event_id = db.Column(db.Integer, db.ForeignKey("events.id"), nullable=True)
    checked_in_by_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=True)
    checked_in_at = db.Column(db.DateTime, default=utcnow, nullable=False)
    device_info = db.Column(db.String(500), nullable=True)

    checked_in_by = db.relationship("User", foreign_keys=[checked_in_by_id])

    def __repr__(self):
        return f"<CheckIn guest_id={self.guest_id} at={self.checked_in_at}>"


class AuditLog(db.Model):
    __tablename__ = "audit_logs"
    __table_args__ = (
        db.Index("ix_audit_logs_created_at", "created_at"),
        db.Index("ix_audit_logs_action", "action"),
        db.Index("ix_audit_logs_username", "username"),
    )

    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=True)
    username = db.Column(db.String(100), nullable=True)
    action = db.Column(db.String(50), nullable=False)
    target_type = db.Column(db.String(50), nullable=True)
    target_id = db.Column(db.String(50), nullable=True)
    details = db.Column(db.Text, nullable=True)
    ip_address = db.Column(db.String(45), nullable=True)
    created_at = db.Column(db.DateTime, default=utcnow, nullable=False)

    user = db.relationship("User", backref="audit_logs", lazy=True)

    def __repr__(self):
        return f"<AuditLog {self.action} by {self.username} at {self.created_at}>"


class SmtpSettings(db.Model):
    """Глобальные настройки SMTP для рассылки приглашений."""
    __tablename__ = "smtp_settings"

    id = db.Column(db.Integer, primary_key=True)
    mail_server = db.Column(db.String(255), nullable=False, default="smtp.yandex.ru")
    mail_port = db.Column(db.Integer, nullable=False, default=465)
    mail_use_ssl = db.Column(db.Boolean, nullable=False, default=True)
    mail_username = db.Column(db.String(255), nullable=False, default="")
    mail_password = db.Column(db.String(1024), nullable=False, default="")
    mail_default_sender = db.Column(db.String(255), nullable=True)
    use_local_outlook = db.Column(db.Boolean, nullable=False, default=False)
    use_ews = db.Column(db.Boolean, nullable=False, default=False)
    ews_url = db.Column(db.String(500), nullable=True)

    # IMAP copy of sent messages
    imap_server = db.Column(db.String(255), nullable=True)
    imap_port = db.Column(db.Integer, nullable=False, default=993)
    imap_use_ssl = db.Column(db.Boolean, nullable=False, default=True)
    imap_username = db.Column(db.String(255), nullable=True)
    imap_password = db.Column(db.String(1024), nullable=True)
    imap_folder = db.Column(db.String(255), nullable=True)
    imap_save_copy = db.Column(db.Boolean, nullable=False, default=False)

    updated_at = db.Column(db.DateTime, default=utcnow, onupdate=utcnow, nullable=False)

    @property
    def mail_mode(self):
        if self.use_local_outlook:
            return "outlook"
        if self.use_ews:
            return "ews"
        return "smtp"

    def set_mail_password(self, password):
        from app.utils.secrets import encrypt_secret
        self.mail_password = encrypt_secret(password)

    def get_mail_password(self):
        from app.utils.secrets import decrypt_secret
        return decrypt_secret(self.mail_password)

    def set_imap_password(self, password):
        from app.utils.secrets import encrypt_secret
        self.imap_password = encrypt_secret(password)

    def get_imap_password(self):
        from app.utils.secrets import decrypt_secret
        return decrypt_secret(self.imap_password)

    def encrypt_legacy_passwords(self):
        """Encrypt plaintext values created by older InviteMe versions."""
        from app.utils.secrets import PREFIX
        changed = False
        if self.mail_password and not self.mail_password.startswith(PREFIX):
            self.set_mail_password(self.mail_password)
            changed = True
        if self.imap_password and not self.imap_password.startswith(PREFIX):
            self.set_imap_password(self.imap_password)
            changed = True
        return changed

    @classmethod
    def get_settings(cls):
        settings = cls.query.first()
        if not settings:
            settings = cls()
            db.session.add(settings)
            db.session.commit()
        return settings

    @classmethod
    def apply_to_app(cls, app):
        """Применяет сохранённые настройки к конфигурации Flask-приложения."""
        try:
            settings = cls.query.first()
            if not settings:
                return
            app.config["MAIL_SERVER"] = settings.mail_server or app.config.get("MAIL_SERVER", "")
            app.config["MAIL_PORT"] = settings.mail_port or app.config.get("MAIL_PORT", 465)
            app.config["MAIL_USE_SSL"] = settings.mail_use_ssl
            app.config["MAIL_USERNAME"] = settings.mail_username or app.config.get("MAIL_USERNAME", "")
            app.config["MAIL_PASSWORD"] = settings.get_mail_password() or app.config.get("MAIL_PASSWORD", "")
            app.config["MAIL_DEFAULT_SENDER"] = settings.mail_default_sender or settings.mail_username or app.config.get("MAIL_DEFAULT_SENDER", "")
            app.config["MAIL_USE_LOCAL_OUTLOOK"] = settings.use_local_outlook
            app.config["MAIL_USE_EWS"] = settings.use_ews
            app.config["EWS_URL"] = settings.ews_url or ""

            app.config["IMAP_SERVER"] = settings.imap_server or ""
            app.config["IMAP_PORT"] = settings.imap_port or 993
            app.config["IMAP_USE_SSL"] = settings.imap_use_ssl
            app.config["IMAP_USERNAME"] = settings.imap_username or settings.mail_username or app.config.get("IMAP_USERNAME", "")
            app.config["IMAP_PASSWORD"] = settings.get_imap_password() or settings.get_mail_password() or app.config.get("IMAP_PASSWORD", "")
            app.config["IMAP_FOLDER"] = settings.imap_folder or "Sent"
            app.config["IMAP_SAVE_COPY"] = settings.imap_save_copy
        except Exception:
            pass

    def __repr__(self):
        return f"<SmtpSettings {self.mail_server}:{self.mail_port} {self.mail_username}>"