Legal Document Analyzer

"""
Contract Analysis Module

Analyzes contracts to extract key terms, obligations, rights, and liabilities.
"""

import re
from typing import Dict, List


class ContractAnalyzer:
    """Analyzes contract documents for key information."""

    def analyze_contract(self, contract_data: Dict) -> Dict:
        """
        Perform comprehensive contract analysis.

        Args:
            contract_data: Dictionary with parsed contract data

        Returns:
            Dictionary with contract analysis
        """
        analysis = {
            "contract_type": self._identify_contract_type(contract_data),
            "parties_involved": contract_data.get("parties"),
            "key_terms": self._extract_key_terms(contract_data),
            "obligations": self._extract_obligations(contract_data),
            "rights": self._extract_rights(contract_data),
            "liabilities": self._extract_liabilities(contract_data),
            "termination_conditions": self._extract_termination(contract_data),
            "dispute_resolution": self._extract_dispute_resolution(contract_data)
        }
        return analysis

    def _identify_contract_type(self, contract_data: Dict) -> str:
        """Identify the type of contract."""
        keywords = {
            "nda": ["confidential", "non-disclosure", "proprietary"],
            "employment": ["employment", "salary", "position", "employee"],
            "service": ["services", "service provider", "agreement"],
            "purchase": ["purchase", "sale", "buyer", "seller"],
            "lease": ["lease", "tenant", "landlord", "rent"]
        }

        text = contract_data.get("full_text", "").lower()
        scores = {}

        for contract_type, keywords_list in keywords.items():
            scores[contract_type] = sum(
                1 for keyword in keywords_list if keyword in text
            )

        return max(scores, key=scores.get) if scores else "unknown"

    def _extract_key_terms(self, contract_data: Dict) -> Dict:
        """Extract key terms from contract."""
        key_terms = {
            "effective_date": self._find_date(contract_data, "effective|commencement"),
            "expiration_date": self._find_date(contract_data, "expiration|end|termination"),
            "renewal_terms": self._find_renewal_terms(contract_data),
            "payment_terms": self._find_payment_terms(contract_data),
            "performance_metrics": self._find_performance_metrics(contract_data)
        }
        return key_terms

    def _extract_obligations(self, contract_data: Dict) -> List[str]:
        """Extract obligations from contract."""
        text = contract_data.get("full_text", "")
        pattern = r'(?:shall|must|agree to|required to)\s+(.+?)(?:\.|;|,)'
        matches = re.finditer(pattern, text, re.IGNORECASE)
        return [match.group(1) for match in matches]

    def _extract_rights(self, contract_data: Dict) -> List[str]:
        """Extract rights from contract."""
        text = contract_data.get("full_text", "")
        pattern = r'(?:may|can|has the right to|entitled to)\s+(.+?)(?:\.|;|,)'
        matches = re.finditer(pattern, text, re.IGNORECASE)
        return [match.group(1) for match in matches]

    def _extract_liabilities(self, contract_data: Dict) -> List[str]:
        """Extract liability clauses from contract."""
        # Placeholder for liability extraction
        return []

    def _extract_termination(self, contract_data: Dict) -> Dict:
        """Extract termination conditions from contract."""
        # Placeholder for termination extraction
        return {}

    def _extract_dispute_resolution(self, contract_data: Dict) -> Dict:
        """Extract dispute resolution clauses."""
        # Placeholder for dispute resolution extraction
        return {}

    def _find_date(self, contract_data: Dict, pattern: str) -> str:
        """Find date matching pattern."""
        # Placeholder for date finding
        return ""

    def _find_renewal_terms(self, contract_data: Dict) -> Dict:
        """Find renewal terms."""
        # Placeholder for renewal terms extraction
        return {}

    def _find_payment_terms(self, contract_data: Dict) -> Dict:
        """Find payment terms."""
        # Placeholder for payment terms extraction
        return {}

    def _find_performance_metrics(self, contract_data: Dict) -> List[str]:
        """Find performance metrics."""
        # Placeholder for performance metrics extraction
        return []

"""
Contract Risk Analysis Module

Identifies and assesses various risks in legal contracts.
"""

from typing import Dict, List


class ContractRiskAnalyzer:
    """Identifies risks in contracts."""

    def identify_risks(self, contract_data: Dict) -> Dict:
        """
        Identify all risks in contract.

        Args:
            contract_data: Dictionary with parsed contract data

        Returns:
            Dictionary with identified risks by category
        """
        return {
            "financial_risks": self._analyze_financial_risks(contract_data),
            "legal_risks": self._analyze_legal_risks(contract_data),
            "operational_risks": self._analyze_operational_risks(contract_data),
            "compliance_risks": self._analyze_compliance_risks(contract_data)
        }

    def _analyze_financial_risks(self, contract_data: Dict) -> List[Dict]:
        """Analyze financial risks in contract."""
        risks = []

        # Check for unlimited liability
        if "unlimited liability" in contract_data.get("full_text", "").lower():
            risks.append({
                "severity": "HIGH",
                "description": "Unlimited liability clause found",
                "recommendation": "Negotiate cap on liability"
            })

        # Check for price escalation clauses
        if "price increase" in contract_data.get("full_text", "").lower():
            risks.append({
                "severity": "MEDIUM",
                "description": "Price escalation clause present",
                "recommendation": "Clarify escalation limits"
            })

        return risks

    def _analyze_legal_risks(self, contract_data: Dict) -> List[Dict]:
        """Analyze legal risks in contract."""
        risks = []

        # Check for ambiguous language
        ambiguous_terms = self._find_ambiguous_terms(contract_data)
        if ambiguous_terms:
            risks.append({
                "severity": "MEDIUM",
                "description": f"Ambiguous terms found: {ambiguous_terms}",
                "recommendation": "Clarify definitions"
            })

        # Check for conflicting clauses
        conflicts = self._find_conflicting_clauses(contract_data)
        if conflicts:
            risks.append({
                "severity": "HIGH",
                "description": f"Conflicting clauses: {conflicts}",
                "recommendation": "Resolve conflicts"
            })

        return risks

    def _analyze_operational_risks(self, contract_data: Dict) -> List[Dict]:
        """Analyze operational risks in contract."""
        # Placeholder for operational risk analysis
        return []

    def _analyze_compliance_risks(self, contract_data: Dict) -> List[Dict]:
        """Analyze compliance risks in contract."""
        risks = []

        # Check for GDPR/data privacy compliance
        if self._contains_personal_data_handling(contract_data):
            if not self._has_data_protection_clause(contract_data):
                risks.append({
                    "severity": "HIGH",
                    "description": "No data protection clause for personal data handling",
                    "recommendation": "Add GDPR/privacy compliance clause"
                })

        return risks

    def _find_ambiguous_terms(self, contract_data: Dict) -> List[str]:
        """Find ambiguous terms in contract."""
        # Placeholder for ambiguous terms detection
        return []

    def _find_conflicting_clauses(self, contract_data: Dict) -> List[str]:
        """Find conflicting clauses in contract."""
        # Placeholder for conflict detection
        return []

    def _contains_personal_data_handling(self, contract_data: Dict) -> bool:
        """Check if contract involves personal data handling."""
        # Placeholder for personal data detection
        return False

    def _has_data_protection_clause(self, contract_data: Dict) -> bool:
        """Check if contract has data protection clause."""
        # Placeholder for data protection clause detection
        return False

"""
Legal Document Parser Module

Handles parsing and extraction of content from legal documents
in PDF, DOCX, and text formats.
"""

import pypdf
from docx import Document
import re
from typing import Dict, List


class LegalDocumentParser:
    """Parses legal documents and extracts structured content."""

    def parse_contract(self, file_path: str) -> Dict:
        """
        Parse contract document based on file type.

        Args:
            file_path: Path to contract file

        Returns:
            Dictionary with parsed contract structure
        """
        if file_path.endswith('.pdf'):
            return self._parse_pdf(file_path)
        elif file_path.endswith('.docx'):
            return self._parse_docx(file_path)
        else:
            return self._parse_text(file_path)

    def _parse_pdf(self, file_path: str) -> Dict:
        """Extract text from PDF."""
        reader = pypdf.PdfReader(file_path)
        text = ""
        for page in reader.pages:
            text += page.extract_text()
        return self._structure_document(text)

    def _parse_docx(self, file_path: str) -> Dict:
        """Extract text from DOCX."""
        doc = Document(file_path)
        text = "\n".join([para.text for para in doc.paragraphs])
        return self._structure_document(text)

    def _parse_text(self, file_path: str) -> Dict:
        """Extract text from plain text file."""
        with open(file_path, 'r') as f:
            text = f.read()
        return self._structure_document(text)

    def _structure_document(self, text: str) -> Dict:
        """Structure extracted text into document components."""
        return {
            "full_text": text,
            "sections": self._extract_sections(text),
            "clauses": self._extract_clauses(text),
            "definitions": self._extract_definitions(text),
            "parties": self._extract_parties(text),
            "dates": self._extract_dates(text)
        }

    def _extract_sections(self, text: str) -> List[str]:
        """Find and extract document sections."""
        pattern = r'^(?:SECTION|§|Article|Part|Chapter)\s+[\w\d\.]+\s*[-:]?\s*(.+)$'
        matches = re.finditer(pattern, text, re.MULTILINE)
        return [match.group(0) for match in matches]

    def _extract_clauses(self, text: str) -> List[str]:
        """Extract clauses from document."""
        # Placeholder for clause extraction logic
        return []

    def _extract_definitions(self, text: str) -> Dict[str, str]:
        """Extract defined terms from document."""
        # Placeholder for definition extraction
        return {}

    def _extract_parties(self, text: str) -> List[str]:
        """Extract party names from document."""
        # Placeholder for party extraction
        return []

    def _extract_dates(self, text: str) -> List[str]:
        """Extract dates from document."""
        # Placeholder for date extraction
        return []

"""
Legal Report Generation Module

Generates comprehensive legal analysis reports for contracts.
"""

from typing import Dict, List


class LegalReportGenerator:
    """Generates legal analysis reports."""

    def generate_analysis_report(self, analysis: Dict, risks: Dict) -> str:
        """
        Generate comprehensive contract analysis report.

        Args:
            analysis: Contract analysis results
            risks: Risk assessment results

        Returns:
            Formatted report as string
        """
        report = f"""
# Contract Analysis Report

## Contract Overview
- Type: {analysis.get('contract_type')}
- Parties: {analysis.get('parties_involved')}

## Key Terms
{self._format_key_terms(analysis.get('key_terms', {}))}

## Obligations & Rights
### Obligations
{self._format_list(analysis.get('obligations', []))}

### Rights
{self._format_list(analysis.get('rights', []))}

## Risk Assessment
{self._format_risks(risks)}

## Recommendations
{self._generate_recommendations(analysis, risks)}
        """
        return report

    def _format_key_terms(self, key_terms: Dict) -> str:
        """Format key terms for report."""
        formatted = ""
        for term, value in key_terms.items():
            formatted += f"- **{term.replace('_', ' ').title()}**: {value}\n"
        return formatted

    def _format_list(self, items: List) -> str:
        """Format list items for report."""
        if not items:
            return "None identified"
        return "\n".join([f"- {item}" for item in items])

    def _format_risks(self, risks: Dict) -> str:
        """Format risks for report."""
        formatted = ""
        for risk_type, risk_list in risks.items():
            formatted += f"\n### {risk_type.replace('_', ' ').title()}\n"
            for risk in risk_list:
                formatted += f"- **[{risk.get('severity')}]** {risk.get('description')}\n"
                formatted += f"  Recommendation: {risk.get('recommendation')}\n"
        return formatted

    def _generate_recommendations(self, analysis: Dict, risks: Dict) -> str:
        """Generate overall recommendations."""
        # Placeholder for recommendation generation
        return "Review all identified risks and implement recommended actions."