from flask import Flask, render_template, request, redirect, url_for, send_from_directory
from content.posts import BLOG_POSTS
from flask_logic.logic import get_enriched_post, get_comments_for_post, save_comment

# 🌟 IMPORT THE content from separate files.
from content.posts import BLOG_POSTS
from content.about_text import ABOUT, TITLE
app = Flask(__name__)


import csv
import datetime
import os, math

COMMENT_FILE = 'content/comments.csv'
MAX_FILE_SIZE_BYTES = 5 * 1024 * 1024  # 5 Megabytes
POSTS_PER_PAGE = 5  # posts per page limit here


@app.route('/post/<int:post_id>/comment', methods=['POST'])
def post_comment(post_id):
    # Honeypot stays in app.py (it's a web-security concern)
    if request.form.get('honeypot'):
        return redirect(url_for('post_detail', post_id=post_id))

    author = request.form.get('author')
    content = request.form.get('content')

    # Just call the logic function
    success = save_comment(post_id, author, content)
    
    # Optional: You could flash a message if success is False
    return redirect(url_for('post_detail', post_id=post_id))
# --- Routes ---


def calculate_pagination(posts, posts_per_page, page):
    """
    Calculate pagination parameters for blog posts.
    
    Args:
        posts (list): Full list of blog posts
        posts_per_page (int): Number of posts per page
        page (int): Current page number (1-indexed)
    
    Returns:
        dict: Pagination data including:
            - posts_to_show: Posts for current page
            - prev_url: Previous page URL or None
            - next_url: Next page URL or None
            - current_page: Current page number
            - total_pages: Total number of pages
            - total_posts: Total number of posts
    """
    # Sort posts by ID newest first
    sorted_posts = sorted(posts, key=lambda x: x['id'], reverse=True)
    
    total_posts = len(sorted_posts)
    total_pages = math.ceil(total_posts / posts_per_page)
    
    # Clamp page to valid range
    page = max(1, min(page, total_pages))
    
    start = (page - 1) * posts_per_page
    end = start + posts_per_page
    
    posts_to_show = sorted_posts[start:end]
    
    prev_url = url_for('home', page=page - 1) if page > 1 else None
    next_url = url_for('home', page=page + 1) if end < total_posts else None
    
    return {
        'posts_to_show': posts_to_show,
        'prev_url': prev_url,
        'next_url': next_url,
        'current_page': page,
        'total_pages': total_pages,
        'total_posts': total_posts
    }

@app.route('/')
def home():
    """Home page with paginated blog posts."""
    page = request.args.get('page', 1, type=int)
    blog_title = TITLE
    
    pagination = calculate_pagination(BLOG_POSTS, POSTS_PER_PAGE, page)
    
    return render_template('index.html', 
                          posts=pagination['posts_to_show'],
                          prev_url=pagination['prev_url'],
                          next_url=pagination['next_url'],
                          current_page=pagination['current_page'],
                          total_pages=pagination['total_pages'],
                          blog_title=blog_title,
                          total_posts=pagination['total_posts'])





@app.route('/about')
def about():
    about_txt = ABOUT
    """Renders the About page."""
    return render_template('about.html', about_txt = about_txt, blog_title = TITLE)


@app.route('/post/<int:post_id>')
def post_detail(post_id):
    context = {"used_components": set()}

    post = get_enriched_post(post_id, BLOG_POSTS)
    if not post:
        return "Post not found", 404
        
    comments = get_comments_for_post(post_id)
    context["used_components"].add("image")


    #processed_content = render_content(post['content'], context=context)

    css_files = []
    for comp in context["used_components"]:
        css_files.append(f"css/components/{comp}.css")

    return render_template(
        "post_detail.html",
        post=post,
        comments=comments, 
        blog_title = TITLE,
        component_css=css_files
    )



@app.route('/content/image/<path:filename>')
def content_image_files(filename):
    directory = 'content/image'
    full_path = os.path.join(os.getcwd(), directory, filename)  # Your actual file location
    print(f"Requested: {filename}")
    print(f"Directory: {os.getcwd()}/{directory}")
    print(f"Full path: {full_path}")
    print(f"Exists: {os.path.exists(full_path)}")
    
    if not os.path.exists(full_path):
        return f"File not found: {full_path}", 404
    
    return send_from_directory(directory, filename)

if __name__ == '__main__':
    app.run(debug=True)