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}>'