Employment Timeline Conflicts

from datetime import date, timedelta
from dataclasses import dataclass
from typing import List, Optional

@dataclass
class Employment:
    employer: str
    start_date: date
    end_date: Optional[date]
    position: str
    source: str
    source_authority: float  # 0-1, higher = more authoritative
    location: Optional[str] = None
    full_time: bool = True

class EmploymentTimelineValidator:
    """Validate employment timeline across documents"""
    
    SOURCE_AUTHORITY = {
        "voe": 1.0,
        "w2": 0.9,
        "tax_return": 0.85,
        "pay_stub": 0.8,
        "credit_report": 0.6,
        "application": 0.5
    }
    
    def build_timeline(self, documents: list) -> dict:
        """Build employment timeline from all documents"""
        
        employments = []
        
        for doc in documents:
            doc_type = doc.get("type")
            authority = self.SOURCE_AUTHORITY.get(doc_type, 0.5)
            
            if doc_type == "application":
                for emp in doc.get("employment_history", []):
                    employments.append(Employment(
                        employer=self.normalize_employer(emp["employer"]),
                        start_date=emp["start_date"],
                        end_date=emp.get("end_date"),
                        position=emp.get("position", ""),
                        source="application",
                        source_authority=authority,
                        location=emp.get("location")
                    ))
            
            elif doc_type == "voe":
                employments.append(Employment(
                    employer=self.normalize_employer(doc["employer"]),
                    start_date=doc["hire_date"],
                    end_date=doc.get("termination_date"),
                    position=doc.get("position", ""),
                    source="voe",
                    source_authority=authority,
                    full_time=doc.get("full_time", True)
                ))
            
            elif doc_type == "w2":
                # W-2 confirms employment for that year
                tax_year = doc["tax_year"]
                employments.append(Employment(
                    employer=self.normalize_employer(doc["employer_name"]),
                    start_date=date(tax_year, 1, 1),
                    end_date=date(tax_year, 12, 31),
                    position="",  # W-2 doesn't have position
                    source="w2",
                    source_authority=authority
                ))
            
            elif doc_type == "pay_stub":
                employments.append(Employment(
                    employer=self.normalize_employer(doc["employer"]),
                    start_date=doc.get("hire_date", doc["pay_period_start"]),
                    end_date=None,  # Current
                    position=doc.get("position", ""),
                    source="pay_stub",
                    source_authority=authority
                ))
        
        # Sort by start date
        employments.sort(key=lambda e: e.start_date)
        
        return {
            "employments": employments,
            "timeline": self.merge_timeline(employments)
        }
    
    def validate_timeline(self, timeline: dict) -> dict:
        """Validate employment timeline for conflicts"""
        
        result = {
            "conflicts": [],
            "gaps": [],
            "risk_indicators": [],
            "risk_score": 0.0
        }
        
        employments = timeline["employments"]
        
        # Check for date conflicts
        for i, emp1 in enumerate(employments):
            for emp2 in employments[i+1:]:
                if self.same_employer(emp1.employer, emp2.employer):
                    conflict = self.check_date_conflict(emp1, emp2)
                    if conflict:
                        result["conflicts"].append(conflict)
        
        # Check for impossible overlaps
        overlaps = self.find_impossible_overlaps(employments)
        result["conflicts"].extend(overlaps)
        
        # Check for gaps
        gaps = self.find_gaps(employments)
        result["gaps"] = gaps
        
        # Check application vs VOE
        app_emp = [e for e in employments if e.source == "application"]
        voe_emp = [e for e in employments if e.source == "voe"]
        
        for app in app_emp:
            for voe in voe_emp:
                if self.same_employer(app.employer, voe.employer):
                    date_diff = abs((app.start_date - voe.start_date).days)
                    if date_diff > 180:  # 6 month variance
                        result["conflicts"].append({
                            "type": "start_date_conflict",
                            "employer": app.employer,
                            "application_date": str(app.start_date),
                            "voe_date": str(voe.start_date),
                            "difference_days": date_diff,
                            "severity": "high"
                        })
                        result["risk_score"] += 0.25
        
        # Calculate overall risk
        if result["conflicts"]:
            result["risk_indicators"].append("timeline_conflicts")
            result["risk_score"] += len(result["conflicts"]) * 0.15
        
        if len(gaps) > 0:
            total_gap_days = sum(g["days"] for g in gaps)
            if total_gap_days > 90:
                result["risk_indicators"].append("employment_gaps")
                result["risk_score"] += 0.2
        
        result["risk_score"] = min(result["risk_score"], 1.0)
        
        return result
    
    def find_impossible_overlaps(self, employments: list) -> list:
        """Find overlapping full-time employment in different locations"""
        
        overlaps = []
        
        full_time = [e for e in employments if e.full_time]
        
        for i, emp1 in enumerate(full_time):
            for emp2 in full_time[i+1:]:
                if self.same_employer(emp1.employer, emp2.employer):
                    continue
                
                # Check for date overlap
                if self.dates_overlap(emp1, emp2):
                    # Different locations?
                    if emp1.location and emp2.location:
                        if not self.same_location(emp1.location, emp2.location):
                            overlaps.append({
                                "type": "impossible_overlap",
                                "employer1": emp1.employer,
                                "employer2": emp2.employer,
                                "location1": emp1.location,
                                "location2": emp2.location,
                                "overlap_period": self.get_overlap_period(emp1, emp2),
                                "severity": "critical"
                            })
        
        return overlaps
    
    def find_gaps(self, employments: list) -> list:
        """Find gaps in employment history"""
        
        gaps = []
        
        # Sort by end date, filter to ended employments
        ended = [e for e in employments if e.end_date]
        ended.sort(key=lambda e: e.end_date)
        
        for i in range(len(ended) - 1):
            current_end = ended[i].end_date
            next_start = ended[i + 1].start_date
            
            gap_days = (next_start - current_end).days
            
            if gap_days > 30:  # Significant gap
                gaps.append({
                    "from_employer": ended[i].employer,
                    "to_employer": ended[i + 1].employer,
                    "gap_start": str(current_end),
                    "gap_end": str(next_start),
                    "days": gap_days
                })
        
        return gaps
    
    def normalize_employer(self, name: str) -> str:
        """Normalize employer name for matching"""
        
        name = name.lower().strip()
        
        # Remove common suffixes
        suffixes = [
            "inc", "inc.", "incorporated",
            "llc", "l.l.c.", "limited liability",
            "corp", "corp.", "corporation",
            "co", "co.", "company",
            "ltd", "ltd.", "limited"
        ]
        
        for suffix in suffixes:
            if name.endswith(f" {suffix}"):
                name = name[:-len(suffix)-1]
        
        return name.strip()
    
    def same_employer(self, name1: str, name2: str) -> bool:
        """Check if two employer names refer to same company"""
        
        n1 = self.normalize_employer(name1)
        n2 = self.normalize_employer(name2)
        
        if n1 == n2:
            return True
        
        # Check if one contains the other
        if n1 in n2 or n2 in n1:
            return True
        
        return False
    
    def dates_overlap(self, emp1: Employment, emp2: Employment) -> bool:
        """Check if two employments overlap in time"""
        
        end1 = emp1.end_date or date.today()
        end2 = emp2.end_date or date.today()
        
        return emp1.start_date <= end2 and emp2.start_date <= end1