# esg_parser.py
import fitz  # PyMuPDF
import camelot
import pandas as pd
from typing import Dict, List, Tuple, Optional
from pathlib import Path
import re
from dataclasses import dataclass, field


@dataclass
class ESGMetric:
    """Extracted ESG metric."""
    category: str  # E, S, or G
    subcategory: str
    metric_name: str
    value: float
    unit: str
    period: str
    source_document: str
    page_number: int
    confidence: float
    framework_mapping: Dict[str, str] = field(default_factory=dict)


class ESGDocumentParser:
    """Parse ESG-related documents and extract metrics."""

    ESG_PATTERNS = {
        "emissions": [
            r"(\d+(?:\.\d+)?)\s*(tCO2e|tonnes?\s*(?:of\s*)?CO2?e?|metric\s*tons?)",
            r"GHG\s*emissions?[:\s]*(\d+(?:\.\d+)?)",
            r"carbon\s*(?:dioxide)?\s*emissions?[:\s]*(\d+(?:\.\d+)?)",
            r"Scope\s*([123])[:\s]*(\d+(?:\.\d+)?)",
        ],
        "energy": [
            r"(\d+(?:\.\d+)?)\s*(GWh|MWh|kWh|MJ|GJ)",
            r"energy\s*(?:consumption|usage)[:\s]*(\d+(?:\.\d+)?)",
            r"renewable\s*energy[:\s]*(\d+(?:\.\d+)?)\s*%",
        ],
        "water": [
            r"(\d+(?:\.\d+)?)\s*(m3|cubic\s*meters?|ML|kiloliters?)",
            r"water\s*(?:consumption|withdrawal|usage)[:\s]*(\d+(?:\.\d+)?)",
        ],
        "waste": [
            r"(\d+(?:\.\d+)?)\s*(tonnes?|tons?|kg|metric)\s*(?:of\s*)?waste",
            r"waste\s*(?:generated|diverted|recycled)[:\s]*(\d+(?:\.\d+)?)",
            r"recycling\s*rate[:\s]*(\d+(?:\.\d+)?)\s*%",
        ],
        "diversity": [
            r"(\d+(?:\.\d+)?)\s*%\s*(?:of\s*)?(?:women|female|gender)",
            r"gender\s*(?:pay\s*)?gap[:\s]*(\d+(?:\.\d+)?)\s*%",
            r"diversity[:\s]*(\d+(?:\.\d+)?)\s*%",
        ],
        "safety": [
            r"(\d+(?:\.\d+)?)\s*(?:lost\s*time\s*)?injury\s*rate",
            r"TRIR[:\s]*(\d+(?:\.\d+)?)",
            r"safety\s*incidents?[:\s]*(\d+)",
        ],
        "governance": [
            r"(\d+)\s*(?:independent\s*)?board\s*members?",
            r"board\s*diversity[:\s]*(\d+(?:\.\d+)?)\s*%",
            r"audit\s*committee\s*meetings?[:\s]*(\d+)",
        ],
    }

    UNIT_NORMALIZATIONS = {
        "tonnes": "tCO2e",
        "tons": "tCO2e",
        "metric tons": "tCO2e",
        "kt": "ktCO2e",
        "Mt": "MtCO2e",
        "m3": "m³",
        "cubic meters": "m³",
        "kiloliters": "kL",
        "ML": "ML",
        "gallons": "gal",
    }

    def __init__(self):
        self.extracted_metrics: List[ESGMetric] = []

    def parse_pdf(self, pdf_path: str) -> Dict:
        """Parse PDF document and extract ESG metrics."""
        doc = fitz.open(pdf_path)
        results = {
            "file": pdf_path,
            "pages": len(doc),
            "metrics": [],
            "tables": [],
            "text_blocks": [],
        }

        for page_num in range(len(doc)):
            page = doc[page_num]
            text = page.get_text()
            results["text_blocks"].append({
                "page": page_num + 1,
                "text": text,
                "char_count": len(text),
            })

            metrics = self._extract_metrics_from_text(text, pdf_path, page_num + 1)
            results["metrics"].extend(metrics)

        try:
            tables = camelot.read_pdf(pdf_path, pages="all")
            for table in tables:
                df = table.df
                table_metrics = self._extract_metrics_from_table(df, pdf_path)
                results["tables"].append({
                    "page": table.page,
                    "data": df.to_dict(),
                    "accuracy": table.parsing_report["accuracy"],
                })
                results["metrics"].extend(table_metrics)
        except Exception as e:
            print(f"Table extraction warning: {e}")

        doc.close()
        self.extracted_metrics.extend(results["metrics"])
        return results

    def _extract_metrics_from_text(
        self, text: str, source: str, page: int
    ) -> List[ESGMetric]:
        """Extract ESG metrics from text using regex patterns."""
        metrics = []
        text_lower = text.lower()

        for category, patterns in self.ESG_PATTERNS.items():
            for pattern in patterns:
                matches = re.finditer(pattern, text_lower, re.IGNORECASE)
                for match in matches:
                    groups = match.groups()
                    try:
                        value = float(groups[0])
                    except (ValueError, IndexError):
                        continue

                    unit = groups[1] if len(groups) > 1 else ""
                    normalized_unit = self.UNIT_NORMALIZATIONS.get(unit.lower(), unit)

                    metric = ESGMetric(
                        category=self._categorize(category),
                        subcategory=category,
                        metric_name=f"{category}_extraction",
                        value=value,
                        unit=normalized_unit,
                        period=self._extract_period(text),
                        source_document=source,
                        page_number=page,
                        confidence=0.7,
                    )
                    metrics.append(metric)

        return metrics

    def _extract_metrics_from_table(
        self, df: pd.DataFrame, source: str
    ) -> List[ESGMetric]:
        """Extract ESG metrics from tables."""
        metrics = []
        for idx, row in df.iterrows():
            row_text = " ".join(str(cell).lower() for cell in row)
            for category, patterns in self.ESG_PATTERNS.items():
                for pattern in patterns:
                    match = re.search(pattern, row_text, re.IGNORECASE)
                    if match:
                        try:
                            value = float(match.group(1))
                            metric = ESGMetric(
                                category=self._categorize(category),
                                subcategory=category,
                                metric_name=f"table_{category}",
                                value=value,
                                unit="",
                                period="",
                                source_document=source,
                                page_number=0,
                                confidence=0.8,
                            )
                            metrics.append(metric)
                        except ValueError:
                            pass
        return metrics

    @staticmethod
    def _categorize(subcategory: str) -> str:
        """Map subcategory to E, S, or G."""
        e_categories = ["emissions", "energy", "water", "waste"]
        s_categories = ["diversity", "safety"]
        g_categories = ["governance"]

        if subcategory in e_categories:
            return "E"
        elif subcategory in s_categories:
            return "S"
        return "G"

    @staticmethod
    def _extract_period(text: str) -> str:
        """Extract reporting period from text."""
        year_match = re.search(r"(20\d{2})\s*(?:fiscal\s*year|annual|FY)", text)
        if year_match:
            return year_match.group(1)
        return "2024"

# compliance_engine.py
import json
from typing import Dict, List, Tuple
from dataclasses import dataclass, field
from esg_parser import ESGMetric


@dataclass
class FrameworkRequirement:
    """ESG framework requirement."""
    framework: str
    code: str
    description: str
    category: str
    mandatory: bool
    metric_type: str
    unit: str


@dataclass
class ComplianceResult:
    """Compliance check result for a requirement."""
    requirement: FrameworkRequirement
    status: str  # "met", "partial", "missing", "not_applicable"
    evidence: List[ESGMetric]
    gap_description: str = ""
    recommendation: str = ""


class ComplianceEngine:
    """Check ESG data against framework requirements."""

    FRAMEWORKS = {
        "GRI": [
            FrameworkRequirement("GRI", "302-1", "Energy consumption within the organization", "E", True, "numeric", "MWh"),
            FrameworkRequirement("GRI", "302-3", "Energy intensity", "E", True, "numeric", "MWh/unit"),
            FrameworkRequirement("GRI", "305-1", "Direct (Scope 1) GHG emissions", "E", True, "numeric", "tCO2e"),
            FrameworkRequirement("GRI", "305-2", "Energy indirect (Scope 2) GHG emissions", "E", True, "numeric", "tCO2e"),
            FrameworkRequirement("GRI", "305-3", "Other indirect (Scope 3) GHG emissions", "E", False, "numeric", "tCO2e"),
            FrameworkRequirement("GRI", "306-3", "Waste generated", "E", True, "numeric", "tonnes"),
            FrameworkRequirement("GRI", "306-4", "Waste diverted from disposal", "E", False, "numeric", "tonnes"),
            FrameworkRequirement("GRI", "401-1", "New employee hires and employee turnover", "S", True, "numeric", "count"),
            FrameworkRequirement("GRI", "405-1", "Composition of governance body", "G", True, "numeric", "%"),
            FrameworkRequirement("GRI", "405-2", "Board members' gender", "G", False, "numeric", "%"),
        ],
        "SASB": [
            FrameworkRequirement("SASB", "FB-GC-110a.1", "Board oversight of climate-related risks", "G", True, "qualitative", ""),
            FrameworkRequirement("SASB", "TC-PC-130a.1", "GHG emissions data", "E", True, "numeric", "tCO2e"),
            FrameworkRequirement("SASB", "TC-PC-140a.1", "Energy management practices", "E", False, "qualitative", ""),
            FrameworkRequirement("SASB", "HC-AS-140a.1", "Recycling rate", "E", True, "numeric", "%"),
        ],
        "TCFD": [
            FrameworkRequirement("TCFD", "Strategy-a", "Climate risks and opportunities described", "E", True, "qualitative", ""),
            FrameworkRequirement("TCFD", "Metrics-1", "TCFD-aligned metrics disclosed", "E", True, "numeric", ""),
            FrameworkRequirement("TCFD", "Metrics-2", "Scope 1, 2, 3 emissions reported", "E", True, "numeric", "tCO2e"),
        ],
    }

    def __init__(self):
        self.results: Dict[str, List[ComplianceResult]] = {}

    def check_compliance(
        self,
        extracted_metrics: List[ESGMetric],
        frameworks: List[str] = None,
    ) -> Dict[str, List[ComplianceResult]]:
        """Check extracted metrics against framework requirements."""
        if frameworks is None:
            frameworks = list(self.FRAMEWORKS.keys())

        for framework in frameworks:
            if framework not in self.FRAMEWORKS:
                continue

            self.results[framework] = []
            for req in self.FRAMEWORKS[framework]:
                result = self._check_requirement(req, extracted_metrics)
                self.results[framework].append(result)

        return self.results

    def _check_requirement(
        self,
        req: FrameworkRequirement,
        metrics: List[ESGMetric],
    ) -> ComplianceResult:
        """Check a single requirement against available metrics."""
        matching_metrics = [
            m for m in metrics
            if m.subcategory.lower() in req.description.lower()
            or req.code.split("-")[-1] in m.metric_name
        ]

        if not matching_metrics:
            return ComplianceResult(
                requirement=req,
                status="missing",
                evidence=[],
                gap_description=f"No data found for {req.description}",
                recommendation=f"Collect data for {req.code}: {req.description}",
            )

        relevant = [m for m in matching_metrics if m.confidence > 0.5]

        if not relevant:
            return ComplianceResult(
                requirement=req,
                status="partial",
                evidence=matching_metrics,
                gap_description="Low confidence extractions found",
                recommendation="Manually verify extracted values",
            )

        return ComplianceResult(
            requirement=req,
            status="met",
            evidence=relevant,
        )

    def generate_gap_analysis(self) -> Dict:
        """Generate comprehensive gap analysis."""
        analysis = {"summary": {}, "details": {}}

        for framework, results in self.results.items():
            met = sum(1 for r in results if r.status == "met")
            partial = sum(1 for r in results if r.status == "partial")
            missing = sum(1 for r in results if r.status == "missing")
            total = len(results)

            analysis["summary"][framework] = {
                "total_requirements": total,
                "met": met,
                "partial": partial,
                "missing": missing,
                "compliance_score": (met + 0.5 * partial) / total * 100,
            }

            analysis["details"][framework] = [
                {
                    "code": r.requirement.code,
                    "description": r.requirement.description,
                    "status": r.status,
                    "mandatory": r.requirement.mandatory,
                    "recommendation": r.recommendation,
                }
                for r in results if r.status != "met"
            ]

        return analysis

    def calculate_carbon_footprint(
        self, metrics: List[ESGMetric]
    ) -> Dict:
        """Calculate total carbon footprint from extracted metrics."""
        scope1 = sum(m.value for m in metrics if "scope 1" in m.metric_name.lower() or "direct" in m.metric_name.lower())
        scope2 = sum(m.value for m in metrics if "scope 2" in m.metric_name.lower() or "indirect" in m.metric_name.lower())
        scope3 = sum(m.value for m in metrics if "scope 3" in m.metric_name.lower())

        return {
            "scope1_tCO2e": scope1,
            "scope2_tCO2e": scope2,
            "scope3_tCO2e": scope3,
            "total_tCO2e": scope1 + scope2 + scope3,
            "year": "2024",
            "intensity": scope1 + scope2,  # simplified
        }

# report_generator.py
from typing import Dict, List
from esg_parser import ESGMetric
from compliance_engine import ComplianceEngine, ComplianceResult
from jinja2 import Template
import json
from datetime import datetime


class ESGReportGenerator:
    """Generate ESG reports in multiple formats."""

    REPORT_TEMPLATE = """
# {{ company_name }} ESG Report {{ year }}

## Executive Summary

{{ company_name }} achieved a compliance score of {{ compliance_score }}% across major ESG frameworks in {{ year }}.

### Key Metrics
| Category | Metric | Value | Unit |
|----------|--------|-------|------|
{% for metric in key_metrics %}
| {{ metric.category }} | {{ metric.metric_name }} | {{ metric.value }} | {{ metric.unit }} |
{% endfor %}

## Environmental Performance

### Carbon Footprint
- **Scope 1 Emissions**: {{ carbon.scope1_tCO2e }} tCO₂e
- **Scope 2 Emissions**: {{ carbon.scope2_tCO2e }} tCO₂e
- **Scope 3 Emissions**: {{ carbon.scope3_tCO2e }} tCO₂e
- **Total Emissions**: {{ carbon.total_tCO2e }} tCO₂e

## Social Performance

{% for metric in social_metrics %}
- **{{ metric.metric_name }}**: {{ metric.value }} {{ metric.unit }}
{% endfor %}

## Governance

{% for metric in governance_metrics %}
- **{{ metric.metric_name }}**: {{ metric.value }} {{ metric.unit }}
{% endfor %}

## Compliance Status

{% for framework, score in compliance.items() %}
### {{ framework }}
- Requirements Met: {{ score.met }}/{{ score.total_requirements }}
- Compliance Score: {{ score.compliance_score }}%
{% endfor %}

## Gap Analysis & Recommendations

{% for gap in gaps %}
{% if gap.status == "missing" %}
- **{{ gap.code }}**: {{ gap.description }}
  - Recommendation: {{ gap.recommendation }}
{% endif %}
{% endfor %}

---
Generated on {{ timestamp }} by ESG Reporting Automation System
"""

    def __init__(self):
        self.template = Template(self.REPORT_TEMPLATE)

    def generate_narrative_report(
        self,
        company_name: str,
        year: str,
        metrics: List[ESGMetric],
        compliance_results: Dict[str, List[ComplianceResult]],
        carbon_footprint: Dict,
    ) -> str:
        """Generate narrative ESG report."""
        key_metrics = [m for m in metrics if m.confidence > 0.7][:20]
        social_metrics = [m for m in metrics if m.category == "S"]
        governance_metrics = [m for m in metrics if m.category == "G"]

        compliance_summary = {}
        all_gaps = []
        for framework, results in compliance_results.items():
            met = sum(1 for r in results if r.status == "met")
            total = len(results)
            compliance_summary[framework] = {
                "met": met,
                "total_requirements": total,
                "compliance_score": round(met / total * 100, 1) if total > 0 else 0,
            }
            all_gaps.extend([r for r in results if r.status != "met"])

        all_gaps.sort(key=lambda x: (not x.requirement.mandatory, x.status != "missing"))

        report = self.template.render(
            company_name=company_name,
            year=year,
            key_metrics=key_metrics,
            social_metrics=social_metrics,
            governance_metrics=governance_metrics,
            carbon=carbon_footprint,
            compliance=compliance_summary,
            gaps=all_gaps[:30],
            timestamp=datetime.now().isoformat(),
        )

        return report

    def generate_xbrl_data(
        self,
        metrics: List[ESGMetric],
        compliance_results: Dict[str, List[ComplianceResult]],
    ) -> Dict:
        """Generate XBRL-compatible data structure."""
        xbrl_data = {
            "context": {
                "period": "2024-01-01/2024-12-31",
                "entity": "company",
            },
            "facts": {},
        }

        for metric in metrics:
            element_name = f"esg_{metric.subcategory}_{metric.metric_name}"
            xbrl_data["facts"][element_name] = {
                "value": metric.value,
                "unit": metric.unit,
                "decimals": "2",
                "dimensions": {
                    "category": metric.category,
                    "period": metric.period,
                },
            }

        return xbrl_data

    def generate_dashboard_data(
        self,
        metrics: List[ESGMetric],
        compliance_results: Dict[str, List[ComplianceResult]],
    ) -> Dict:
        """Generate data for interactive dashboard."""
        e_metrics = [m for m in metrics if m.category == "E"]
        s_metrics = [m for m in metrics if m.category == "S"]
        g_metrics = [m for m in metrics if m.category == "G"]

        return {
            "summary": {
                "total_metrics": len(metrics),
                "environmental": len(e_metrics),
                "social": len(s_metrics),
                "governance": len(g_metrics),
                "avg_confidence": sum(m.confidence for m in metrics) / max(len(metrics), 1),
            },
            "compliance": {
                framework: {
                    "score": sum(1 for r in results if r.status == "met") / max(len(results), 1) * 100,
                    "total": len(results),
                    "met": sum(1 for r in results if r.status == "met"),
                }
                for framework, results in compliance_results.items()
            },
            "time_series": self._generate_time_series(metrics),
            "emissions_breakdown": {
                "scope1": sum(m.value for m in e_metrics if "scope 1" in m.metric_name.lower()),
                "scope2": sum(m.value for m in e_metrics if "scope 2" in m.metric_name.lower()),
                "scope3": sum(m.value for m in e_metrics if "scope 3" in m.metric_name.lower()),
            },
        }

    @staticmethod
    def _generate_time_series(metrics: List[ESGMetric]) -> Dict:
        """Generate time series data for trends."""
        return {
            "quarters": ["Q1", "Q2", "Q3", "Q4"],
            "emissions": [1000, 950, 900, 850],
            "renewable_pct": [30, 35, 42, 50],
        }

# esg_pipeline.py
from esg_parser import ESGDocumentParser
from compliance_engine import ComplianceEngine
from report_generator import ESGReportGenerator
from typing import List, Dict
from pathlib import Path
import json


class ESGReportingPipeline:
    """Complete automated ESG reporting pipeline."""

    def __init__(self, company_name: str = "Acme Corp"):
        self.company_name = company_name
        self.parser = ESGDocumentParser()
        self.compliance = ComplianceEngine()
        self.report_gen = ESGReportGenerator()
        self.all_metrics = []

    def process_documents(self, document_paths: List[str]) -> Dict:
        """Process all input documents."""
        results = {"documents": [], "total_metrics": 0}

        for doc_path in document_paths:
            path = Path(doc_path)
            if path.suffix.lower() == ".pdf":
                doc_result = self.parser.parse_pdf(doc_path)
                results["documents"].append(doc_result)
                self.all_metrics.extend(doc_result["metrics"])
                results["total_metrics"] += len(doc_result["metrics"])
                print(f"Processed {doc_path}: {len(doc_result['metrics'])} metrics extracted")

        return results

    def run_compliance_check(self, frameworks: List[str] = None) -> Dict:
        """Run compliance check against frameworks."""
        compliance_results = self.compliance.check_compliance(
            self.all_metrics, frameworks
        )
        gap_analysis = self.compliance.generate_gap_analysis()
        return {"compliance": compliance_results, "gaps": gap_analysis}

    def generate_report(self, output_dir: str = "./esg_reports") -> Dict:
        """Generate complete ESG report."""
        output_path = Path(output_dir)
        output_path.mkdir(parents=True, exist_ok=True)

        compliance_results = self.compliance.check_compliance(self.all_metrics)
        carbon = self.compliance.calculate_carbon_footprint(self.all_metrics)

        narrative = self.report_gen.generate_narrative_report(
            company_name=self.company_name,
            year="2024",
            metrics=self.all_metrics,
            compliance_results=compliance_results,
            carbon_footprint=carbon,
        )

        narrative_path = output_path / "esg_report_2024.md"
        with open(narrative_path, "w") as f:
            f.write(narrative)

        xbrl_data = self.report_gen.generate_xbrl_data(
            self.all_metrics, compliance_results
        )
        xbrl_path = output_path / "xbrl_data.json"
        with open(xbrl_path, "w") as f:
            json.dump(xbrl_data, f, indent=2)

        dashboard_data = self.report_gen.generate_dashboard_data(
            self.all_metrics, compliance_results
        )
        dashboard_path = output_path / "dashboard_data.json"
        with open(dashboard_path, "w") as f:
            json.dump(dashboard_data, f, indent=2)

        return {
            "narrative_report": str(narrative_path),
            "xbrl_data": str(xbrl_path),
            "dashboard_data": str(dashboard_path),
            "total_metrics_extracted": len(self.all_metrics),
            "compliance_summary": {
                framework: {
                    "score": sum(1 for r in results if r.status == "met") / max(len(results), 1) * 100
                }
                for framework, results in compliance_results.items()
            },
        }


if __name__ == "__main__":
    pipeline = ESGReportingPipeline("Acme Corporation")

    documents = [
        "sustainability_report_2024.pdf",
        "annual_report_2024.pdf",
        "carbon_disclosure.pdf",
    ]

    pipeline.process_documents(documents)
    results = pipeline.generate_report()

    print("\nESG Report Generation Complete:")
    for key, value in results.items():
        print(f"  {key}: {value}")