# -*- coding: utf-8 -*-
"""
PDF Generation Service for Analyst Reports
Converts markdown reports to PDF format with Chinese character support
"""
import io
import re
from typing import Optional
from datetime import datetime
from reportlab.lib.pagesizes import A4
from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
from reportlab.lib.units import cm
from reportlab.lib.enums import TA_LEFT, TA_CENTER
from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, PageBreak
from reportlab.pdfbase import pdfmetrics
from reportlab.pdfbase.ttfonts import TTFont
from reportlab.lib.colors import HexColor
import markdown


class PDFGenerator:
    """Generate PDF reports from markdown content"""
    
    def __init__(self):
        """Initialize PDF generator with Chinese font support"""
        import os
        from reportlab.pdfbase.cidfonts import UnicodeCIDFont
        
        # Try to register custom Cactus Classical Serif font first
        self.custom_font = None
        custom_font_path = os.path.join(
            os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))),
            'Cactus_Classical_Serif',
            'CactusClassicalSerif-Regular.ttf'
        )
        
        if os.path.exists(custom_font_path):
            try:
                pdfmetrics.registerFont(TTFont('CactusClassicalSerif', custom_font_path))
                self.custom_font = 'CactusClassicalSerif'
                print(f"Successfully registered Cactus Classical Serif font")
            except Exception as e:
                print(f"Error registering custom font: {e}")
        
        # Register Chinese font as fallback for CJK characters
        try:
            # Register Chinese font (Traditional Chinese support)
            pdfmetrics.registerFont(UnicodeCIDFont('STSong-Light'))
            self.chinese_font = 'STSong-Light'
        except Exception as e:
            # If CID font registration fails, try alternative method
            try:
                pdfmetrics.registerFont(UnicodeCIDFont('STHeiti-Light'))
                self.chinese_font = 'STHeiti-Light'
            except Exception:
                # Last resort: use MSung for Traditional Chinese
                try:
                    pdfmetrics.registerFont(UnicodeCIDFont('MSung-Light'))
                    self.chinese_font = 'MSung-Light'
                except Exception:
                    # Fallback to basic font
                    self.chinese_font = 'Helvetica'
                    print("Warning: Could not register Chinese font")
        
        # Set primary font: use custom font if available, otherwise Chinese font
        self.primary_font = self.custom_font if self.custom_font else self.chinese_font
    
    def generate_analyst_report_pdf(
        self,
        analyst_name: str,
        ticker: str,
        analysis_date: str,
        report_content: str,
    ) -> bytes:
        """
        Generate a PDF from analyst report content
        
        Args:
            analyst_name: Name of the analyst
            ticker: Stock ticker symbol
            analysis_date: Date of analysis
            report_content: Markdown formatted report content
            
        Returns:
            PDF file content as bytes
        """
        buffer = io.BytesIO()
        
        # Create PDF document
        doc = SimpleDocTemplate(
            buffer,
            pagesize=A4,
            rightMargin=2*cm,
            leftMargin=2*cm,
            topMargin=2*cm,
            bottomMargin=2*cm,
        )
        
        # Container for the 'Flowable' objects
        elements = []
        
        # Define styles
        styles = getSampleStyleSheet()
        
        # Custom styles with proper spacing and wrapping
        title_style = ParagraphStyle(
            'CustomTitle',
            parent=styles['Heading1'],
            fontName=self.primary_font,
            fontSize=24,
            textColor=HexColor('#1a1a1a'),
            spaceAfter=30,
            alignment=TA_CENTER,
            wordWrap='CJK',
        )
        
        subtitle_style = ParagraphStyle(
            'CustomSubtitle',
            parent=styles['Normal'],
            fontName=self.primary_font,
            fontSize=12,
            textColor=HexColor('#666666'),
            spaceAfter=12,
            alignment=TA_CENTER,
            wordWrap='CJK',
        )
        
        heading_style = ParagraphStyle(
            'CustomHeading',
            parent=styles['Heading2'],
            fontName=self.primary_font,
            fontSize=16,
            textColor=HexColor('#2c3e50'),
            spaceAfter=12,
            spaceBefore=16,
            wordWrap='CJK',
        )
        
        body_style = ParagraphStyle(
            'CustomBody',
            parent=styles['Normal'],
            fontName=self.primary_font,
            fontSize=10,
            leading=16,  # Increased from 14 for better readability
            textColor=HexColor('#333333'),
            spaceAfter=10,
            wordWrap='CJK',
            splitLongWords=True,
        )
        
        # Add title
        title = f"{analyst_name}"
        elements.append(Paragraph(title, title_style))
        elements.append(Spacer(1, 0.3*cm))
        
        # Add metadata
        metadata = f"{ticker} | {analysis_date}"
        elements.append(Paragraph(metadata, subtitle_style))
        elements.append(Spacer(1, 0.5*cm))
        
        # Convert markdown to simple text (basic conversion)
        # Clean markdown formatting
        content = self._clean_markdown(report_content)
        
        # Split content into paragraphs
        paragraphs = content.split('\n')
        
        for para in paragraphs:
            para = para.strip()
            if not para:
                elements.append(Spacer(1, 0.2*cm))
                continue
            
            # Check if it's a heading
            if para.startswith('# '):
                text = para[2:]
                elements.append(Paragraph(text, heading_style))
            elif para.startswith('## '):
                text = para[3:]
                elements.append(Paragraph(text, heading_style))
            elif para.startswith('### '):
                text = para[4:]
                elements.append(Paragraph(text, heading_style))
            else:
                # Regular paragraph - escape HTML chars and handle special characters
                text = self._escape_html(para)
                # Ensure proper UTF-8 handling
                elements.append(Paragraph(text, body_style))
        
        # Build PDF
        doc.build(elements)
        
        # Get the PDF content
        pdf_content = buffer.getvalue()
        buffer.close()
        
        return pdf_content
    
    def _clean_markdown(self, text: str) -> str:
        """
        Clean markdown formatting for PDF
        
        Args:
            text: Markdown text
            
        Returns:
            Cleaned text
        """
        # Remove markdown links but keep text
        text = re.sub(r'\[([^\]]+)\]\([^\)]+\)', r'\1', text)
        
        # Remove bold/italic markers carefully to avoid orphan characters
        text = re.sub(r'\*\*([^\*]+)\*\*', r'\1', text)
        text = re.sub(r'(?<!\*)\*([^\*]+)\*(?!\*)', r'\1', text)  # Avoid double asterisks
        text = re.sub(r'__([^_]+)__', r'\1', text)
        text = re.sub(r'(?<!_)_([^_]+)_(?!_)', r'\1', text)  # Avoid double underscores
        
        # Remove code blocks
        text = re.sub(r'```[^`]*```', ' ', text, flags=re.DOTALL)  # Replace with space not empty
        text = re.sub(r'`([^`]+)`', r'\1', text)
        
        # Clean up bullet points
        text = re.sub(r'^\s*[\*\-\+]\s+', '• ', text, flags=re.MULTILINE)
        
        # Remove horizontal rules
        text = re.sub(r'^[\-\*\_]{3,}\s*$', '', text, flags=re.MULTILINE)
        
        # Remove multiple consecutive spaces
        text = re.sub(r' {2,}', ' ', text)
        
        # Remove orphaned single characters that might be markdown artifacts
        text = re.sub(r'(?<=[^\w])([*_`~#])(?=[^\w])', '', text)
        
        return text
    
    def _escape_html(self, text: str) -> str:
        """
        Escape HTML special characters for PDF
        
        Args:
            text: Text to escape
            
        Returns:
            Escaped text
        """
        text = text.replace('&', '&amp;')
        text = text.replace('<', '&lt;')
        text = text.replace('>', '&gt;')
        return text