# app/models/project_document.py

from flask_login import UserMixin
from datetime import datetime
from app.extensions import db
import os


class ProjectDocument(db.Model):
    """مدل اسناد و مدارک پروژه"""
    __tablename__ = 'project_documents'
    __table_args__ = {'extend_existing': True}
    
    id = db.Column(db.Integer, primary_key=True)
    project_id = db.Column(db.Integer, db.ForeignKey('projects.id'), nullable=False)
    
    # اطلاعات سند
    title = db.Column(db.String(200), nullable=False)
    description = db.Column(db.Text, nullable=True)
    file_path = db.Column(db.String(500), nullable=False)
    file_type = db.Column(db.String(50), nullable=True)  # pdf, image, doc, xls, etc.
    file_size = db.Column(db.Integer, nullable=True)  # حجم فایل به بایت
    
    # دسته‌بندی
    category = db.Column(db.String(50), nullable=True)  # contract, report, photo, invoice, certificate, other
    
    # وضعیت
    is_approved = db.Column(db.Boolean, default=False)
    approved_by = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=True)
    approved_at = db.Column(db.DateTime, nullable=True)
    
    # نسخه‌بندی
    version = db.Column(db.Integer, default=1)
    parent_document_id = db.Column(db.Integer, db.ForeignKey('project_documents.id'), nullable=True)
    
    # متادیتا
    metadata = db.Column(db.JSON, nullable=True)  # اطلاعات اضافی مانند ابعاد تصویر، تعداد صفحات و ...
    
    # زمان‌ها
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    created_by = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=True)
    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    
    # ========== روابط ==========
    
    # رابطه با Project
    project = db.relationship(
        'Project',
        foreign_keys=[project_id],
        backref='documents_list'  # نام یکتا
    )
    
    # رابطه با User (Approver)
    approver = db.relationship(
        'User',
        foreign_keys=[approved_by],
        backref='approved_documents'  # نام یکتا
    )
    
    # رابطه با User (Creator)
    creator = db.relationship(
        'User',
        foreign_keys=[created_by],
        backref='created_documents'  # نام یکتا
    )
    
    # رابطه برای نسخه‌بندی (خودارجاعی)
    parent_document = db.relationship(
        'ProjectDocument',
        remote_side=[id],
        backref='versions',
        foreign_keys=[parent_document_id]
    )
    
    # ========== متدها ==========
    
    @property
    def file_name(self):
        """دریافت نام فایل از مسیر"""
        if self.file_path:
            return os.path.basename(self.file_path)
        return None
    
    @property
    def file_extension(self):
        """دریافت پسوند فایل"""
        if self.file_path:
            return self.file_path.split('.')[-1].lower() if '.' in self.file_path else None
        return None
    
    @property
    def is_image(self):
        """بررسی اینکه آیا فایل تصویر است"""
        image_extensions = ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp', 'svg']
        return self.file_extension in image_extensions
    
    @property
    def is_pdf(self):
        """بررسی اینکه آیا فایل PDF است"""
        return self.file_extension == 'pdf'
    
    @property
    def is_document(self):
        """بررسی اینکه آیا فایل سند متنی است"""
        doc_extensions = ['doc', 'docx', 'txt', 'rtf', 'odt']
        return self.file_extension in doc_extensions
    
    @property
    def is_spreadsheet(self):
        """بررسی اینکه آیا فایل صفحه گسترده است"""
        sheet_extensions = ['xls', 'xlsx', 'csv', 'ods']
        return self.file_extension in sheet_extensions
    
    def get_category_display(self):
        """نمایش دسته‌بندی به فارسی"""
        category_map = {
            'contract': 'قرارداد',
            'report': 'گزارش',
            'photo': 'تصویر',
            'invoice': 'فاکتور',
            'certificate': 'مدارک',
            'other': 'سایر'
        }
        return category_map.get(self.category, self.category)
    
    def get_file_type_display(self):
        """نمایش نوع فایل به فارسی"""
        type_map = {
            'pdf': 'PDF',
            'jpg': 'تصویر',
            'jpeg': 'تصویر',
            'png': 'تصویر',
            'gif': 'تصویر',
            'doc': 'سند ورد',
            'docx': 'سند ورد',
            'xls': 'اکسل',
            'xlsx': 'اکسل',
            'txt': 'متن ساده',
            'zip': 'فشرده',
            'rar': 'فشرده'
        }
        return type_map.get(self.file_type, self.file_type)
    
    def get_file_size_display(self):
        """نمایش حجم فایل به صورت خوانا"""
        if not self.file_size:
            return 'نامشخص'
        
        size = self.file_size
        for unit in ['بایت', 'KB', 'MB', 'GB']:
            if size < 1024.0 or unit == 'GB':
                return f"{size:.1f} {unit}"
            size /= 1024.0
        return f"{size:.1f} GB"
    
    def approve(self, user_id):
        """تایید سند توسط کاربر"""
        self.is_approved = True
        self.approved_by = user_id
        self.approved_at = datetime.utcnow()
    
    def reject(self):
        """رد سند"""
        self.is_approved = False
        self.approved_by = None
        self.approved_at = None
    
    def create_new_version(self, new_file_path, user_id, description=None):
        """ایجاد نسخه جدید از سند"""
        new_version = ProjectDocument(
            project_id=self.project_id,
            title=self.title,
            description=description or self.description,
            file_path=new_file_path,
            file_type=self.file_type,
            file_size=self.file_size,
            category=self.category,
            is_approved=False,
            parent_document_id=self.id,
            version=self.version + 1,
            created_by=user_id
        )
        return new_version
    
    def get_version_history(self):
        """دریافت تاریخچه نسخه‌ها"""
        versions = [self]
        current = self
        while current.parent_document:
            current = current.parent_document
            versions.append(current)
        return versions[::-1]  # برگرداندن به ترتیب از قدیمی به جدید
    
    def is_editable_by_user(self, user_id):
        """بررسی اینکه آیا کاربر می‌تواند سند را ویرایش کند"""
        if not self.is_approved:
            return self.created_by == user_id
        return False
    
    def to_dict(self):
        """تبدیل به دیکشنری برای JSON"""
        return {
            'id': self.id,
            'project_id': self.project_id,
            'project_name': self.project.name if self.project else None,
            'title': self.title,
            'description': self.description,
            'file_path': self.file_path,
            'file_name': self.file_name,
            'file_type': self.file_type,
            'file_type_display': self.get_file_type_display(),
            'file_size': self.file_size,
            'file_size_display': self.get_file_size_display(),
            'category': self.category,
            'category_display': self.get_category_display(),
            'is_approved': self.is_approved,
            'is_image': self.is_image,
            'is_pdf': self.is_pdf,
            'version': self.version,
            'parent_document_id': self.parent_document_id,
            'metadata': self.metadata,
            'approved_by': self.approved_by,
            'approver_name': self.approver.fullname if self.approver else None,
            'approved_at': self.approved_at.strftime('%Y-%m-%d %H:%M:%S') if self.approved_at else None,
            'created_at': self.created_at.strftime('%Y-%m-%d %H:%M:%S'),
            'created_by': self.created_by,
            'creator_name': self.creator.fullname if self.creator else None,
            'updated_at': self.updated_at.strftime('%Y-%m-%d %H:%M:%S') if self.updated_at else None
        }
    
    def __repr__(self):
        return f'<ProjectDocument {self.id} - {self.title} - {self.category}>'