from datetime import datetime
import os
from flask_login import UserMixin
from werkzeug.security import generate_password_hash, check_password_hash
from app.extensions import db

class User(UserMixin, db.Model):
    __tablename__ = 'users'
    
    id = db.Column(db.Integer, primary_key=True)
    nickname = 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_active = db.Column(db.Boolean, default=True, nullable=False)
    is_admin = db.Column(db.Boolean, default=False, nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    
    # Relationships
    posts = db.relationship('Post', backref='author', lazy='dynamic', cascade='all, delete-orphan')
    comments = db.relationship('Comment', backref='author', lazy='dynamic', cascade='all, delete-orphan')
    likes = db.relationship('Like', backref='user', lazy='dynamic', cascade='all, delete-orphan')
    
    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 __repr__(self):
        return f'<User {self.nickname}>'

class Post(db.Model):
    __tablename__ = 'posts'
    
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(200), nullable=False)
    subtitle = db.Column(db.String(300))
    content = db.Column(db.Text, nullable=False)
    difficulty = db.Column(db.Integer, default=3, nullable=False)  # 1-5 scale
    media_folder = db.Column(db.String(100))  # Folder name for media files
    published = db.Column(db.Boolean, default=False, nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    
    # Foreign Keys
    author_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
    
    # Relationships
    images = db.relationship('PostImage', backref='post', lazy='dynamic', cascade='all, delete-orphan')
    gpx_files = db.relationship('GPXFile', backref='post', lazy='dynamic', cascade='all, delete-orphan')
    comments = db.relationship('Comment', backref='post', lazy='dynamic', cascade='all, delete-orphan')
    likes = db.relationship('Like', backref='post', lazy='dynamic', cascade='all, delete-orphan')
    map_route = db.relationship('MapRoute', backref='post', uselist=False, cascade='all, delete-orphan', passive_deletes=True)
    
    def get_difficulty_label(self):
        labels = ['Very Easy', 'Easy', 'Moderate', 'Hard', 'Very Hard']
        return labels[self.difficulty - 1] if 1 <= self.difficulty <= 5 else 'Unknown'
    
    def get_like_count(self):
        return self.likes.count()
    
    def get_media_folder_path(self):
        """Get the full path to the post's media folder"""
        if self.media_folder:
            return os.path.join('static', 'media', 'posts', self.media_folder)
        return None
    
    def get_media_url_path(self):
        """Get the URL path to the post's media folder"""
        if self.media_folder:
            return f'/static/media/posts/{self.media_folder}'
        return None
    
    def __repr__(self):
        return f'<Post {self.title}>'

class PostImage(db.Model):
    __tablename__ = 'post_images'
    
    id = db.Column(db.Integer, primary_key=True)
    filename = db.Column(db.String(255), nullable=False)
    original_name = db.Column(db.String(255), nullable=False)
    description = db.Column(db.Text)
    size = db.Column(db.Integer, nullable=False)
    mime_type = db.Column(db.String(100), default='image/jpeg', nullable=False)
    is_cover = db.Column(db.Boolean, default=False, nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    
    # Foreign Keys
    post_id = db.Column(db.Integer, db.ForeignKey('posts.id'), nullable=False)
    
    def get_url(self):
        """Get the URL path to access this image"""
        if self.post.media_folder:
            return f'/static/media/posts/{self.post.media_folder}/images/{self.filename}'
        return f'/static/uploads/images/{self.filename}'  # Fallback for old files
    
    def get_thumbnail_url(self):
        """Get the URL path to access this image's thumbnail"""
        if self.post.media_folder:
            return f'/static/media/posts/{self.post.media_folder}/images/thumbnails/{self.filename}'
        return self.get_url()  # Fallback to main image for old files
    
    def has_thumbnail(self):
        """Check if thumbnail exists for this image"""
        if not self.post.media_folder:
            return False
        
        from flask import current_app
        thumbnail_path = os.path.join(
            current_app.root_path, 'static', 'media', 'posts', 
            self.post.media_folder, 'images', 'thumbnails', self.filename
        )
        return os.path.exists(thumbnail_path)
    
    def __repr__(self):
        return f'<PostImage {self.filename}>'

class GPXFile(db.Model):
    __tablename__ = 'gpx_files'
    
    id = db.Column(db.Integer, primary_key=True)
    filename = db.Column(db.String(255), nullable=False)
    original_name = db.Column(db.String(255), nullable=False)
    size = db.Column(db.Integer, nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    
    # GPX Statistics
    total_distance = db.Column(db.Float, default=0.0)  # in kilometers
    elevation_gain = db.Column(db.Float, default=0.0)  # in meters
    max_elevation = db.Column(db.Float, default=0.0)  # in meters
    min_elevation = db.Column(db.Float, default=0.0)  # in meters
    total_points = db.Column(db.Integer, default=0)  # number of track points
    
    # Foreign Keys
    post_id = db.Column(db.Integer, db.ForeignKey('posts.id'), nullable=False)
    
    def get_url(self):
        """Get the URL path to access this GPX file"""
        if self.post.media_folder:
            return f'/static/media/posts/{self.post.media_folder}/gpx/{self.filename}'
        return f'/static/uploads/gpx/{self.filename}'  # Fallback for old files
    
    def __repr__(self):
        return f'<GPXFile {self.filename}>'

class Comment(db.Model):
    __tablename__ = 'comments'
    
    id = db.Column(db.Integer, primary_key=True)
    content = db.Column(db.Text, nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    
    # Foreign Keys
    author_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
    post_id = db.Column(db.Integer, db.ForeignKey('posts.id'), nullable=False)
    
    def __repr__(self):
        return f'<Comment {self.id}>'

class Like(db.Model):
    __tablename__ = 'likes'
    
    id = db.Column(db.Integer, primary_key=True)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    
    # Foreign Keys
    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
    post_id = db.Column(db.Integer, db.ForeignKey('posts.id'), nullable=False)
    
    # Unique constraint
    __table_args__ = (db.UniqueConstraint('user_id', 'post_id', name='unique_user_post_like'),)
    
    def __repr__(self):
        return f'<Like {self.user_id}-{self.post_id}>'

class MapRoute(db.Model):
    __tablename__ = 'map_routes'
    
    id = db.Column(db.Integer, primary_key=True)
    
    # Route Data (stored as JSON for efficient loading)
    coordinates = db.Column(db.Text, nullable=False)  # JSON array of [lat, lng] points
    simplified_coordinates = db.Column(db.Text)  # Simplified version for map overview
    
    # Route Bounds
    start_latitude = db.Column(db.Float, nullable=False)
    start_longitude = db.Column(db.Float, nullable=False)
    end_latitude = db.Column(db.Float, nullable=False)
    end_longitude = db.Column(db.Float, nullable=False)
    
    # Bounding Box for map fitting
    bounds_north = db.Column(db.Float, nullable=False)
    bounds_south = db.Column(db.Float, nullable=False)
    bounds_east = db.Column(db.Float, nullable=False)
    bounds_west = db.Column(db.Float, nullable=False)
    
    # Route Statistics (copied from GPX processing)
    total_distance = db.Column(db.Float, default=0.0)  # in kilometers
    elevation_gain = db.Column(db.Float, default=0.0)  # in meters
    max_elevation = db.Column(db.Float, default=0.0)  # in meters
    min_elevation = db.Column(db.Float, default=0.0)  # in meters
    total_points = db.Column(db.Integer, default=0)  # original number of points
    simplified_points = db.Column(db.Integer, default=0)  # simplified points count
    
    # Metadata
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    
    # Foreign Keys
    post_id = db.Column(db.Integer, db.ForeignKey('posts.id'), nullable=False, unique=True)
    gpx_file_id = db.Column(db.Integer, db.ForeignKey('gpx_files.id'), nullable=False)
    
    # Relationships
    # Relationship now defined on Post with cascade and passive_deletes
    gpx_file = db.relationship('GPXFile', backref='map_route')
    
    def get_coordinates_json(self):
        """Get coordinates as parsed JSON"""
        import json
        return json.loads(self.coordinates) if self.coordinates else []
    
    def get_simplified_coordinates_json(self):
        """Get simplified coordinates as parsed JSON"""
        import json
        return json.loads(self.simplified_coordinates) if self.simplified_coordinates else []
    
    def get_bounds(self):
        """Get bounding box as dict"""
        return {
            'north': self.bounds_north,
            'south': self.bounds_south,
            'east': self.bounds_east,
            'west': self.bounds_west
        }
    
    def get_start_point(self):
        """Get start point as dict"""
        return {
            'latitude': self.start_latitude,
            'longitude': self.start_longitude
        }
    
    def get_end_point(self):
        """Get end point as dict"""
        return {
            'latitude': self.end_latitude,
            'longitude': self.end_longitude
        }
    
    def __repr__(self):
        return f'<MapRoute for Post {self.post_id}>'

class PageView(db.Model):
    __tablename__ = 'page_views'
    
    id = db.Column(db.Integer, primary_key=True)
    path = db.Column(db.String(255), nullable=False)
    user_agent = db.Column(db.String(500))
    ip_address = db.Column(db.String(45))  # IPv6 can be up to 45 chars
    referer = db.Column(db.String(500))
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    
    # Foreign Keys (optional - for tracking logged-in users)
    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=True)
    post_id = db.Column(db.Integer, db.ForeignKey('posts.id'), nullable=True)
    
    # Relationships
    user = db.relationship('User', backref='page_views')
    post = db.relationship('Post', backref='page_views')
    
    def __repr__(self):
        return f'<PageView {self.path} at {self.created_at}>'


# --- Mail Server Management Models ---
class MailSettings(db.Model):
    __tablename__ = 'mail_settings'
    id = db.Column(db.Integer, primary_key=True)
    enabled = db.Column(db.Boolean, default=False, nullable=False)
    server = db.Column(db.String(255), nullable=False)
    port = db.Column(db.Integer, nullable=False)
    use_tls = db.Column(db.Boolean, default=True, nullable=False)
    username = db.Column(db.String(255))
    password = db.Column(db.String(255))
    default_sender = db.Column(db.String(255))
    provider = db.Column(db.String(50), default='smtp')  # 'smtp' or 'mailrise'
    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)

    def __repr__(self):
        return f'<MailSettings {self.server}:{self.port} enabled={self.enabled}>'

class SentEmail(db.Model):
    __tablename__ = 'sent_emails'
    id = db.Column(db.Integer, primary_key=True)
    recipient = db.Column(db.String(255), nullable=False)
    subject = db.Column(db.String(255), nullable=False)
    body = db.Column(db.Text, nullable=False)
    status = db.Column(db.String(50), default='sent')  # sent, failed, etc.
    error = db.Column(db.Text)
    sent_at = db.Column(db.DateTime, default=datetime.utcnow)
    provider = db.Column(db.String(50), default='smtp')

    def __repr__(self):
        return f'<SentEmail to={self.recipient} subject={self.subject} status={self.status}>'

class ChatRoom(db.Model):
    __tablename__ = 'chat_rooms'
    
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(200), nullable=False)
    description = db.Column(db.Text)
    room_type = db.Column(db.String(50), default='general')  # general, post_discussion, admin_support, password_reset
    category = db.Column(db.String(50), default='general')  # general, technical, maintenance, routes, events, safety, gear, social
    is_private = db.Column(db.Boolean, default=False)
    is_active = db.Column(db.Boolean, default=True)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    last_activity = db.Column(db.DateTime, default=datetime.utcnow)
    
    # Foreign Keys
    created_by_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
    related_post_id = db.Column(db.Integer, db.ForeignKey('posts.id'), nullable=True)  # For post discussions
    
    # Relationships
    created_by = db.relationship('User', backref='created_chat_rooms')
    related_post = db.relationship('Post', backref='chat_rooms')
    messages = db.relationship('ChatMessage', backref='room', lazy='dynamic', cascade='all, delete-orphan')
    participants = db.relationship('ChatParticipant', backref='room', lazy='dynamic', cascade='all, delete-orphan')
    
    def to_dict(self):
        """Convert to dictionary for API responses"""
        return {
            'id': self.id,
            'name': self.name,
            'description': self.description,
            'room_type': self.room_type,
            'is_private': self.is_private,
            'is_active': self.is_active,
            'created_at': self.created_at.isoformat() if self.created_at else None,
            'last_activity': self.last_activity.isoformat() if self.last_activity else None,
            'created_by': {
                'id': self.created_by.id,
                'nickname': self.created_by.nickname
            } if self.created_by else None,
            'related_post': {
                'id': self.related_post.id,
                'title': self.related_post.title
            } if self.related_post else None,
            'participant_count': self.participants.count(),
            'message_count': self.messages.count()
        }
    
    def __repr__(self):
        return f'<ChatRoom {self.name}>'

class ChatParticipant(db.Model):
    __tablename__ = 'chat_participants'
    
    id = db.Column(db.Integer, primary_key=True)
    joined_at = db.Column(db.DateTime, default=datetime.utcnow)
    last_seen = db.Column(db.DateTime, default=datetime.utcnow)
    is_muted = db.Column(db.Boolean, default=False)
    role = db.Column(db.String(50), default='member')  # member, moderator, admin
    
    # Foreign Keys
    room_id = db.Column(db.Integer, db.ForeignKey('chat_rooms.id'), nullable=False)
    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
    
    # Relationships
    user = db.relationship('User', backref='chat_participations')
    
    # Unique constraint
    __table_args__ = (db.UniqueConstraint('room_id', 'user_id', name='unique_room_participant'),)
    
    def to_dict(self):
        """Convert to dictionary for API responses"""
        return {
            'id': self.id,
            'user': {
                'id': self.user.id,
                'nickname': self.user.nickname,
                'is_admin': self.user.is_admin
            },
            'role': self.role,
            'joined_at': self.joined_at.isoformat() if self.joined_at else None,
            'last_seen': self.last_seen.isoformat() if self.last_seen else None,
            'is_muted': self.is_muted
        }
    
    def __repr__(self):
        return f'<ChatParticipant {self.user.nickname} in {self.room.name}>'

class ChatMessage(db.Model):
    __tablename__ = 'chat_messages'
    
    id = db.Column(db.Integer, primary_key=True)
    content = db.Column(db.Text, nullable=False)
    message_type = db.Column(db.String(50), default='text')  # text, system, file, image
    is_edited = db.Column(db.Boolean, default=False)
    is_deleted = db.Column(db.Boolean, default=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    
    # Foreign Keys
    room_id = db.Column(db.Integer, db.ForeignKey('chat_rooms.id'), nullable=False)
    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
    reply_to_id = db.Column(db.Integer, db.ForeignKey('chat_messages.id'), nullable=True)  # For threaded replies
    
    # Relationships
    user = db.relationship('User', backref='chat_messages')
    reply_to = db.relationship('ChatMessage', remote_side=[id], backref='replies')
    
    def to_dict(self):
        """Convert to dictionary for API responses"""
        return {
            'id': self.id,
            'content': self.content,
            'message_type': self.message_type,
            'is_edited': self.is_edited,
            'is_deleted': self.is_deleted,
            'created_at': self.created_at.isoformat() if self.created_at else None,
            'updated_at': self.updated_at.isoformat() if self.updated_at else None,
            'user': {
                'id': self.user.id,
                'nickname': self.user.nickname,
                'is_admin': self.user.is_admin
            },
            'reply_to': {
                'id': self.reply_to.id,
                'content': self.reply_to.content[:100] + '...' if len(self.reply_to.content) > 100 else self.reply_to.content,
                'user_nickname': self.reply_to.user.nickname
            } if self.reply_to else None
        }
    
    def __repr__(self):
        return f'<ChatMessage {self.id} by {self.user.nickname}>'


class PasswordResetRequest(db.Model):
    """Model for tracking password reset requests from chat system"""
    __tablename__ = 'password_reset_requests'
    
    id = db.Column(db.Integer, primary_key=True)
    user_email = db.Column(db.String(120), nullable=False)
    requester_message = db.Column(db.Text)  # Original request message
    status = db.Column(db.String(20), default='pending')  # pending, token_generated, completed, expired
    admin_notes = db.Column(db.Text)  # Admin can add notes
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    
    # Foreign Keys
    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=True)  # Nullable in case user not found
    chat_message_id = db.Column(db.Integer, db.ForeignKey('chat_messages.id'), nullable=True)
    
    # Relationships
    user = db.relationship('User', backref='password_reset_requests')
    chat_message = db.relationship('ChatMessage', backref='password_reset_request')
    tokens = db.relationship('PasswordResetToken', backref='request', cascade='all, delete-orphan')
    
    def __repr__(self):
        return f'<PasswordResetRequest {self.id} for {self.user_email}>'


class PasswordResetToken(db.Model):
    """Model for one-time password reset tokens generated by admin"""
    __tablename__ = 'password_reset_tokens'
    
    id = db.Column(db.Integer, primary_key=True)
    token = db.Column(db.String(255), unique=True, nullable=False)
    is_used = db.Column(db.Boolean, default=False)
    used_at = db.Column(db.DateTime, nullable=True)
    expires_at = db.Column(db.DateTime, nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    user_ip = db.Column(db.String(45), nullable=True)  # IP when token was used
    user_agent = db.Column(db.Text, nullable=True)  # User agent when token was used
    
    # Foreign Keys
    request_id = db.Column(db.Integer, db.ForeignKey('password_reset_requests.id'), nullable=False)
    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
    created_by_admin_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
    
    # Relationships
    user = db.relationship('User', foreign_keys=[user_id], backref='reset_tokens')
    created_by_admin = db.relationship('User', foreign_keys=[created_by_admin_id])
    
    @property
    def is_expired(self):
        return datetime.utcnow() > self.expires_at
    
    @property
    def is_valid(self):
        return not self.is_used and not self.is_expired
    
    def mark_as_used(self, ip_address=None, user_agent=None):
        self.is_used = True
        self.used_at = datetime.utcnow()
        self.user_ip = ip_address
        self.user_agent = user_agent
        db.session.commit()
    
    def __repr__(self):
        return f'<PasswordResetToken {self.token[:8]}... for {self.user.nickname}>'