from app import db
from datetime import datetime

class Progress(db.Model):
    __tablename__ = 'progress'
    
    id = db.Column(db.Integer, primary_key=True)
    student_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
    topic_id = db.Column(db.Integer, db.ForeignKey('topics.id'), nullable=False)
    
    # Reading Stage
    reading_started = db.Column(db.DateTime)
    reading_completed = db.Column(db.DateTime)
    reading_time = db.Column(db.Integer)  # Time spent in seconds
    
    # Comprehension Stage
    comprehension_started = db.Column(db.DateTime)
    comprehension_completed = db.Column(db.DateTime)
    comprehension_score = db.Column(db.Float)
    comprehension_answers = db.Column(db.JSON)  # Store answers and results
    
    # Writing Stage
    writing_started = db.Column(db.DateTime)
    writing_completed = db.Column(db.DateTime)
    writing_score = db.Column(db.Float)
    writing_feedback = db.Column(db.Text)
    
    # Speaking Stage
    speaking_started = db.Column(db.DateTime)
    speaking_completed = db.Column(db.DateTime)
    speaking_scores = db.Column(db.JSON)  # Store detailed speaking assessment scores
    speaking_feedback = db.Column(db.Text)
    
    # Overall Progress
    started_at = db.Column(db.DateTime, default=datetime.utcnow)
    completed_at = db.Column(db.DateTime)
    
    # Relationships
    submissions = db.relationship('Submission',
                                backref='progress',
                                lazy='dynamic',
                                cascade='all, delete-orphan')
    
    def to_dict(self):
        return {
            'id': self.id,
            'student_id': self.student_id,
            'topic_id': self.topic_id,
            'reading_completed': self.reading_completed.strftime('%Y-%m-%d %H:%M:%S') if self.reading_completed else None,
            'comprehension_completed': self.comprehension_completed.strftime('%Y-%m-%d %H:%M:%S') if self.comprehension_completed else None,
            'comprehension_score': self.comprehension_score,
            'writing_completed': self.writing_completed.strftime('%Y-%m-%d %H:%M:%S') if self.writing_completed else None,
            'writing_score': self.writing_score,
            'speaking_completed': self.speaking_completed.strftime('%Y-%m-%d %H:%M:%S') if self.speaking_completed else None,
            'speaking_scores': self.speaking_scores,
            'completed': bool(self.completed_at),
            'started_at': self.started_at.strftime('%Y-%m-%d %H:%M:%S') if self.started_at else None,
            'completed_at': self.completed_at.strftime('%Y-%m-%d %H:%M:%S') if self.completed_at else None
        }
    
    def __repr__(self):
        return f'<Progress {self.student_id}:{self.topic_id}>'


class Submission(db.Model):
    __tablename__ = 'submissions'
    
    id = db.Column(db.Integer, primary_key=True)
    content = db.Column(db.Text, nullable=False)
    content_type = db.Column(db.String(20), nullable=False)  # 'speaking', 'comprehension', etc.
    score = db.Column(db.Float)  # AI-generated score
    status = db.Column(db.String(20), default='pending')  # pending, approved, rejected, needs_revision
    feedback = db.Column(db.Text)  # Keep old column for backward compatibility
    feedback_json = db.Column(db.JSON)  # New JSON column for structured feedback
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    progress_id = db.Column(db.Integer, db.ForeignKey('progress.id'))
    
    # Teacher review fields
    teacher_score = db.Column(db.Float, nullable=True)  # Optional manual score by teacher
    teacher_feedback = db.Column(db.Text, nullable=True)  # Teacher's feedback for student
    teacher_notes = db.Column(db.Text, nullable=True)  # Private notes (optional)
    reviewed_by = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=True)  # Which teacher reviewed
    reviewed_at = db.Column(db.DateTime, nullable=True)  # When reviewed
    
    # Relationships
    reviewer = db.relationship('User', foreign_keys=[reviewed_by], backref='reviewed_submissions')
    
    @property
    def final_score(self):
        """Return teacher score if available, otherwise AI score"""
        return self.teacher_score if self.teacher_score is not None else self.score
    
    @property
    def is_teacher_reviewed(self):
        """Check if teacher has manually reviewed this submission"""
        return self.teacher_score is not None or self.teacher_feedback is not None
    
    def to_dict(self):
        return {
            'id': self.id,
            'content': self.content,
            'content_type': self.content_type,
            'score': self.score,
            'teacher_score': self.teacher_score,
            'final_score': self.final_score,
            'status': self.status,
            'feedback': self.feedback,
            'feedback_json': self.feedback_json,
            'teacher_feedback': self.teacher_feedback,
            'is_teacher_reviewed': self.is_teacher_reviewed,
            'reviewed_at': self.reviewed_at.strftime('%Y-%m-%d %H:%M:%S') if self.reviewed_at else None,
            'created_at': self.created_at.strftime('%Y-%m-%d %H:%M:%S')
        }
    
    def __repr__(self):
        return f'<Submission {self.id}>'