from flask_sqlalchemy import SQLAlchemy
from datetime import datetime
from werkzeug.security import generate_password_hash, check_password_hash
from flask_login import UserMixin

db = SQLAlchemy()

class Word(db.Model):
    __tablename__ = 'words'
    
    id = db.Column(db.Integer, primary_key=True)
    fur_word = db.Column(db.String(200), nullable=False)
    arabic_word = db.Column(db.String(200), nullable=False)
    english_word = db.Column(db.String(200), nullable=False)
    fur_audio_url = db.Column(db.String(500))
    english_audio_url = db.Column(db.String(500))
    category = db.Column(db.String(100))
    difficulty_level = db.Column(db.Integer, default=1)  # 1-5
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    is_active = db.Column(db.Boolean, default=True)
    
    def to_dict(self):
        return {
            'id': self.id,
            'fur_word': self.fur_word,
            'arabic_word': self.arabic_word,
            'english_word': self.english_word,
            'fur_audio_url': self.fur_audio_url,
            'english_audio_url': self.english_audio_url,
            'category': self.category,
            'difficulty_level': self.difficulty_level,
            'created_at': self.created_at.isoformat() if self.created_at else None,
            'updated_at': self.updated_at.isoformat() if self.updated_at else None,
            'is_active': self.is_active,
            'english_synonyms': [s.to_dict() for s in self.english_synonyms],
            'arabic_synonyms': [s.to_dict() for s in self.arabic_synonyms],
            'fur_synonyms': [s.to_dict() for s in self.fur_synonyms]
        }

class Category(db.Model):
    __tablename__ = 'categories'
    
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100), nullable=False, unique=True)
    description = db.Column(db.Text)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    is_active = db.Column(db.Boolean, default=True)
    
class DownloadLog(db.Model):
    __tablename__ = 'download_logs'
    
    id = db.Column(db.Integer, primary_key=True)
    device_id = db.Column(db.String(200))
    download_type = db.Column(db.String(50))  # 'full', 'update'
    words_count = db.Column(db.Integer)
    download_time = db.Column(db.DateTime, default=datetime.utcnow)
    app_version = db.Column(db.String(20))

class EnglishSynonym(db.Model):
    __tablename__ = 'english_synonyms'
    id = db.Column(db.Integer, primary_key=True)
    word_id = db.Column(db.Integer, db.ForeignKey('words.id'), nullable=False)
    synonym_text = db.Column(db.String(200), nullable=False)
    audio_url = db.Column(db.String(500))
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    word = db.relationship('Word', backref=db.backref('english_synonyms', lazy=True, cascade="all, delete-orphan"))

    def to_dict(self):
        return {
            'id': self.id,
            'word_id': self.word_id,
            'synonym_text': self.synonym_text,
            'audio_url': self.audio_url,
            'created_at': self.created_at.isoformat() if self.created_at else None
        }

class ArabicSynonym(db.Model):
    __tablename__ = 'arabic_synonyms'
    id = db.Column(db.Integer, primary_key=True)
    word_id = db.Column(db.Integer, db.ForeignKey('words.id'), nullable=False)
    synonym_text = db.Column(db.String(200), nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    word = db.relationship('Word', backref=db.backref('arabic_synonyms', lazy=True, cascade="all, delete-orphan"))

    def to_dict(self):
        return {
            'id': self.id,
            'word_id': self.word_id,
            'synonym_text': self.synonym_text,
            'created_at': self.created_at.isoformat() if self.created_at else None
        }

class FurSynonym(db.Model):
    __tablename__ = 'fur_synonyms'
    id = db.Column(db.Integer, primary_key=True)
    word_id = db.Column(db.Integer, db.ForeignKey('words.id'), nullable=False)
    synonym_text = db.Column(db.String(200), nullable=False)
    audio_url = db.Column(db.String(500))
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    word = db.relationship('Word', backref=db.backref('fur_synonyms', lazy=True, cascade="all, delete-orphan"))

    def to_dict(self):
        return {
            'id': self.id,
            'word_id': self.word_id,
            'synonym_text': self.synonym_text,
            'audio_url': self.audio_url,
            'created_at': self.created_at.isoformat() if self.created_at else None
        }

class User(UserMixin, db.Model):
    __tablename__ = 'users'
    
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)
    password_hash = db.Column(db.String(255), nullable=False)
    is_admin = db.Column(db.Boolean, default=False)
    is_active = db.Column(db.Boolean, default=True)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    last_login = db.Column(db.DateTime)
    
    def set_password(self, password):
        """تشفير كلمة المرور"""
        self.password_hash = generate_password_hash(password)
    
    def check_password(self, password):
        """التحقق من كلمة المرور"""
        return check_password_hash(self.password_hash, password)
    
    def to_dict(self):
        return {
            'id': self.id,
            'username': self.username,
            'email': self.email,
            'is_admin': self.is_admin,
            'is_active': self.is_active,
            'created_at': self.created_at.isoformat() if self.created_at else None,
            'last_login': self.last_login.isoformat() if self.last_login else None
        }