models.py

"""
Modèles SQLAlchemy - Chantier Tracker
Définition de toutes les tables de la base de données
"""
from datetime import datetime
from flask_sqlalchemy import SQLAlchemy
from flask_login import UserMixin
from werkzeug.security import generate_password_hash, check_password_hash

db = SQLAlchemy()

# Table d'association pour les dépendances entre tâches (many-to-many self-referential)
task_dependencies = db.Table('task_dependencies',
    db.Column('task_id', db.Integer, db.ForeignKey('task.id'), primary_key=True),
    db.Column('depends_on_id', db.Integer, db.ForeignKey('task.id'), primary_key=True)
)

# Table d'association tâche ↔ checklist item (dépendance achat/démarche)
task_checklist = db.Table('task_checklist',
    db.Column('task_id', db.Integer, db.ForeignKey('task.id'), primary_key=True),
    db.Column('checklist_id', db.Integer, db.ForeignKey('checklist_item.id'), primary_key=True)
)


class ChecklistItem(db.Model):
    """Achat ou démarche à effectuer, peut bloquer des tâches"""
    __tablename__ = 'checklist_item'

    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(200), nullable=False)
    category = db.Column(db.String(20), nullable=False)  # 'achat' ou 'demarche'
    done = db.Column(db.Boolean, default=False)
    due_date = db.Column(db.Date, nullable=True)  # Date de livraison / échéance
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    # Tâches qui dépendent de cet item
    blocked_tasks = db.relationship(
        'Task',
        secondary=task_checklist,
        back_populates='checklist_deps'
    )

    def __repr__(self):
        return f'<ChecklistItem {self.category}:{self.title}>'


class User(UserMixin, db.Model):
    """Utilisateur de l'application"""
    __tablename__ = 'user'

    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(64), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)
    password_hash = db.Column(db.String(256), nullable=False)
    role = db.Column(db.String(20), nullable=False, default='owner')  # 'owner' ou 'contractor'
    weekly_summary = db.Column(db.Boolean, default=True)  # Recevoir résumé hebdomadaire
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    # Relations
    comments = db.relationship('Comment', backref='author', lazy='dynamic')

    def set_password(self, password):
        """Hasher le mot de passe"""
        self.password_hash = generate_password_hash(password)

    def check_password(self, password):
        """Vérifier le mot de passe"""
        return check_password_hash(self.password_hash, password)

    def can_delete(self):
        """Seuls les propriétaires peuvent supprimer"""
        return self.role == 'owner'

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


class Floor(db.Model):
    """Étage du bâtiment"""
    __tablename__ = 'floor'

    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(50), nullable=False)  # ex: "RDC", "1er étage"
    order = db.Column(db.Integer, default=0)  # Pour l'ordre d'affichage

    # Relations
    rooms = db.relationship('Room', backref='floor', lazy='dynamic', cascade='all, delete-orphan')

    @property
    def progress(self):
        """Calcul du % d'avancement de l'étage"""
        all_tasks = []
        for room in self.rooms:
            all_tasks.extend(room.tasks.all())
        if not all_tasks:
            return 0
        return int(sum(t.progress for t in all_tasks) / len(all_tasks))

    def __repr__(self):
        return f'<Floor {self.name}>'


class Room(db.Model):
    """Pièce du logement"""
    __tablename__ = 'room'

    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100), nullable=False)  # ex: "Salon", "Chambre 1"
    floor_id = db.Column(db.Integer, db.ForeignKey('floor.id'), nullable=False)
    icon = db.Column(db.String(10), default='🏠')  # Emoji pour la pièce
    color = db.Column(db.String(7), default='#6366f1')  # Couleur hex

    # Relations
    tasks = db.relationship('Task', backref='room', lazy='dynamic')
    photos = db.relationship('Photo', backref='room', lazy='dynamic')

    @property
    def progress(self):
        """Calcul du % d'avancement de la pièce"""
        tasks_list = self.tasks.all()
        if not tasks_list:
            return 0
        return int(sum(t.progress for t in tasks_list) / len(tasks_list))

    @property
    def task_counts(self):
        """Nombre de tâches par statut"""
        tasks_list = self.tasks.all()
        return {
            'todo': sum(1 for t in tasks_list if t.status == 'todo'),
            'in_progress': sum(1 for t in tasks_list if t.status == 'in_progress'),
            'blocked': sum(1 for t in tasks_list if t.status == 'blocked'),
            'done': sum(1 for t in tasks_list if t.status == 'done'),
            'total': len(tasks_list)
        }

    def __repr__(self):
        return f'<Room {self.name}>'


class WorkType(db.Model):
    """Type de travaux (corps de métier)"""
    __tablename__ = 'work_type'

    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100), nullable=False)  # ex: "Plomberie", "Électricité"
    color = db.Column(db.String(7), nullable=False)   # Couleur hex pour le badge
    icon = db.Column(db.String(10), default='🔧')      # Emoji
    contractor_name = db.Column(db.String(100))        # Nom de l'entreprise

    # Relations
    tasks = db.relationship('Task', backref='work_type', lazy='dynamic')

    @property
    def progress(self):
        """Calcul du % d'avancement du type de travaux"""
        tasks_list = self.tasks.all()
        if not tasks_list:
            return 0
        return int(sum(t.progress for t in tasks_list) / len(tasks_list))

    def __repr__(self):
        return f'<WorkType {self.name}>'


class Task(db.Model):
    """Tâche du chantier - entité centrale"""
    __tablename__ = 'task'

    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(200), nullable=False)
    description = db.Column(db.Text)

    # Localisation et catégorie
    room_id = db.Column(db.Integer, db.ForeignKey('room.id'), nullable=False)
    work_type_id = db.Column(db.Integer, db.ForeignKey('work_type.id'), nullable=False)

    # Statut et priorité
    status = db.Column(db.String(20), nullable=False, default='todo')
    # Valeurs : 'todo' | 'in_progress' | 'blocked' | 'done'
    priority = db.Column(db.String(10), nullable=False, default='normal')
    # Valeurs : 'critical' | 'high' | 'normal' | 'low'

    # Planification
    start_date = db.Column(db.Date)
    end_date = db.Column(db.Date)
    actual_end_date = db.Column(db.Date)

    # Avancement
    progress = db.Column(db.Integer, default=0)  # 0 à 100

    # Qui réalise : True = entrepreneur, False = nous-mêmes (défaut)
    is_self_managed = db.Column(db.Boolean, default=False)

    # Métadonnées
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)

    # Relations
    photos = db.relationship('Photo', backref='task', lazy='dynamic', cascade='all, delete-orphan')
    comments = db.relationship('Comment', backref='task', lazy='dynamic', cascade='all, delete-orphan')

    # Dépendances self-referential (tâches dont celle-ci dépend)
    dependencies = db.relationship(
        'Task',
        secondary=task_dependencies,
        primaryjoin=(id == task_dependencies.c.task_id),
        secondaryjoin=(id == task_dependencies.c.depends_on_id),
        backref='dependents',
        lazy='dynamic'
    )

    # Achats / démarches dont cette tâche dépend
    checklist_deps = db.relationship(
        'ChecklistItem',
        secondary=task_checklist,
        back_populates='blocked_tasks'
    )

    @property
    def is_blocked_by_dependencies(self):
        """Vérifie si toutes les dépendances sont terminées"""
        task_blocked = any(dep.status != 'done' for dep in self.dependencies)
        checklist_blocked = any(not item.done for item in self.checklist_deps)
        return task_blocked or checklist_blocked

    def update_status_from_dependencies(self):
        """Force le statut 'bloqué' si les dépendances ne sont pas terminées"""
        if self.is_blocked_by_dependencies and self.status not in ('done', 'blocked'):
            self.status = 'blocked'

    @property
    def status_label(self):
        """Libellé français du statut"""
        labels = {
            'todo': 'À faire',
            'in_progress': 'En cours',
            'blocked': 'Bloquée',
            'done': 'Terminée'
        }
        return labels.get(self.status, self.status)

    @property
    def priority_label(self):
        """Libellé français de la priorité"""
        labels = {
            'critical': 'Critique',
            'high': 'Haute',
            'normal': 'Normale',
            'low': 'Basse'
        }
        return labels.get(self.priority, self.priority)

    @property
    def is_overdue(self):
        """Vérifie si la tâche est en retard"""
        if self.end_date and self.status != 'done':
            return self.end_date < datetime.utcnow().date()
        return False

    def __repr__(self):
        return f'<Task {self.title}>'


class Photo(db.Model):
    """Photo attachée à une tâche ou une pièce"""
    __tablename__ = 'photo'

    id = db.Column(db.Integer, primary_key=True)
    filename = db.Column(db.String(255), nullable=False)
    original_filename = db.Column(db.String(255))
    caption = db.Column(db.String(300))
    task_id = db.Column(db.Integer, db.ForeignKey('task.id'), nullable=True)
    room_id = db.Column(db.Integer, db.ForeignKey('room.id'), nullable=True)
    uploaded_at = db.Column(db.DateTime, default=datetime.utcnow)
    file_size = db.Column(db.Integer)  # Taille en bytes

    def __repr__(self):
        return f'<Photo {self.filename}>'


class Comment(db.Model):
    """Commentaire horodaté sur une tâche"""
    __tablename__ = 'comment'

    id = db.Column(db.Integer, primary_key=True)
    content = db.Column(db.Text, nullable=False)
    task_id = db.Column(db.Integer, db.ForeignKey('task.id'), nullable=False)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    def __repr__(self):
        return f'<Comment by {self.user_id} on task {self.task_id}>'