import sys
import json
from typing import Dict, List, Optional
from datetime import datetime

class EquityGrantError(Exception):
    """Custom exception for equity grant calculation errors"""
    pass

class EquityGrantAnalyzer:
    """
    Analyzes startup equity grants to model post-dilution value, accounting for
    strike price, vesting schedules, and exit scenarios.
    Compatible with Carta export formats v3.2+.
    """

    def __init__(self, grant_data: Dict, exit_multiplier: float = 1.0):
        """
        Initialize analyzer with grant data from HRIS or Carta export.

        Args:
            grant_data: Dict containing grant details (shares, strike_price, vesting_years)
            exit_multiplier: Projected exit valuation multiple (e.g., 10x for Series A)
        """
        self.validate_grant_data(grant_data)
        self.shares = grant_data["shares"]
        self.strike_price = grant_data["strike_price"]
        self.vesting_years = grant_data["vesting_years"]
        self.cliff_years = grant_data.get("cliff_years", 1)
        self.exit_multiplier = exit_multiplier
        self.dilution_rates = grant_data.get("dilution_rates", [0.15, 0.20, 0.25])  # Pre-seed, Seed, Series A

    def validate_grant_data(self, data: Dict) -> None:
        """Validate required grant fields exist and are positive numbers"""
        required = ["shares", "strike_price", "vesting_years"]
        for field in required:
            if field not in data:
                raise EquityGrantError(f"Missing required field: {field}")
            if not isinstance(data[field], (int, float)) or data[field] <= 0:
                raise EquityGrantError(f"Invalid {field}: must be positive number")

    def calculate_post_dilution_shares(self, funding_rounds: int = 3) -> float:
        """
        Calculate shares remaining after N funding rounds of dilution.

        Args:
            funding_rounds: Number of funding rounds before exit (default 3: pre-seed, seed, A)
        Returns:
            Post-dilution share count
        """
        if funding_rounds > len(self.dilution_rates):
            raise EquityGrantError(f"Not enough dilution rates for {funding_rounds} rounds")
        remaining_shares = self.shares
        for i in range(funding_rounds):
            remaining_shares *= (1 - self.dilution_rates[i])
        return remaining_shares

    def calculate_exit_value(self, pre_money_valuation: float) -> float:
        """
        Calculate total grant value at exit, minus strike price cost.

        Args:
            pre_money_valuation: Company valuation before exit (e.g., $100M)
        Returns:
            Net profit from exercising shares at exit
        """
        post_dilution_shares = self.calculate_post_dilution_shares()
        exit_valuation = pre_money_valuation * self.exit_multiplier
        share_price_at_exit = exit_valuation / 1000000  # Assume 1M shares outstanding
        exercise_cost = self.shares * self.strike_price
        gross_value = post_dilution_shares * share_price_at_exit
        return gross_value - exercise_cost

    def generate_vesting_schedule(self) -> List[Dict]:
        """Generate month-by-month vesting schedule with cliff"""
        schedule = []
        total_months = self.vesting_years * 12
        cliff_months = self.cliff_years * 12
        monthly_vest = self.shares / total_months

        for month in range(1, total_months + 1):
            if month < cliff_months:
                vested = 0.0
            else:
                vested = monthly_vest * month if month == total_months else monthly_vest * (month - cliff_months)
            schedule.append({
                "month": month,
                "vested_shares": round(vested, 2),
                "vested_pct": round((vested / self.shares) * 100, 2)
            })
        return schedule

if __name__ == "__main__":
    # Example grant data for a Series Seed startup
    example_grant = {
        "shares": 10000,
        "strike_price": 0.50,
        "vesting_years": 4,
        "cliff_years": 1,
        "dilution_rates": [0.15, 0.20, 0.25]  # Pre-seed, Seed, Series A
    }

    try:
        analyzer = EquityGrantAnalyzer(example_grant, exit_multiplier=12.5)
        exit_val = analyzer.calculate_exit_value(pre_money_valuation=80_000_000)
        print(f"Net exit value for grant: ${exit_val:,.2f}")
        print(f"Post-dilution shares: {analyzer.calculate_post_dilution_shares():,.2f}")

        # Save vesting schedule to JSON
        with open("vesting_schedule.json", "w") as f:
            json.dump(analyzer.generate_vesting_schedule(), f, indent=2)
        print("Vesting schedule saved to vesting_schedule.json")

    except EquityGrantError as e:
        print(f"Grant calculation failed: {e}", file=sys.stderr)
        sys.exit(1)

interface VestingConfig {
    grantId: string;
    shares: number;
    strikePrice: number;
    startDate: Date;
    vestingYears: number;
    cliffYears: number;
    dilutionRates: number[];
}

interface VestingEvent {
    date: Date;
    vestedShares: number;
    exercisedShares: number;
    remainingShares: number;
}

class VestingTracker {
    private config: VestingConfig;
    private exercisedShares: number = 0;
    private earlyExerciseEnabled: boolean;

    constructor(config: VestingConfig, earlyExerciseEnabled: boolean = false) {
        this.validateConfig(config);
        this.config = config;
        this.earlyExerciseEnabled = earlyExerciseEnabled;
    }

    private validateConfig(config: VestingConfig): void {
        if (config.shares <= 0) throw new Error("Shares must be positive");
        if (config.strikePrice <= 0) throw new Error("Strike price must be positive");
        if (config.vestingYears <= 0) throw new Error("Vesting years must be positive");
        if (config.cliffYears > config.vestingYears) throw new Error("Cliff cannot exceed vesting period");
    }

    /**
     * Calculate vested shares as of a given date
     */
    public getVestedShares(asOf: Date): number {
        const monthsElapsed = this.getMonthsBetween(this.config.startDate, asOf);
        const totalMonths = this.config.vestingYears * 12;
        const cliffMonths = this.config.cliffYears * 12;

        if (monthsElapsed < cliffMonths) return 0;

        // Linear vesting post-cliff
        const vestedMonths = Math.min(monthsElapsed - cliffMonths, totalMonths - cliffMonths);
        const monthlyVest = this.config.shares / (totalMonths - cliffMonths);
        return Math.round(vestedMonths * monthlyVest * 100) / 100;
    }

    /**
     * Exercise shares early (if enabled) or post-vesting
     */
    public exerciseShares(sharesToExercise: number, asOf: Date): VestingEvent {
        if (!this.earlyExerciseEnabled && this.getVestedShares(asOf) < sharesToExercise) {
            throw new Error("Cannot exercise unvested shares without early exercise enabled");
        }
        if (this.exercisedShares + sharesToExercise > this.config.shares) {
            throw new Error("Cannot exercise more shares than granted");
        }

        const exerciseCost = sharesToExercise * this.config.strikePrice;
        this.exercisedShares += sharesToExercise;

        return {
            date: asOf,
            vestedShares: this.getVestedShares(asOf),
            exercisedShares: sharesToExercise,
            remainingShares: this.config.shares - this.exercisedShares
        };
    }

    /**
     * Calculate post-dilution share count after N funding rounds
     */
    public getPostDilutionShares(fundingRounds: number): number {
        if (fundingRounds > this.config.dilutionRates.length) {
            throw new Error(`Not enough dilution rates for ${fundingRounds} rounds`);
        }
        let remaining = this.config.shares;
        for (let i = 0; i < fundingRounds; i++) {
            remaining *= (1 - this.config.dilutionRates[i]);
        }
        return Math.round(remaining * 100) / 100;
    }

    private getMonthsBetween(start: Date, end: Date): number {
        return (end.getFullYear() - start.getFullYear()) * 12 + (end.getMonth() - start.getMonth());
    }

    /**
     * Generate full vesting schedule as JSON
     */
    public generateSchedule(): VestingEvent[] {
        const schedule: VestingEvent[] = [];
        const totalMonths = this.config.vestingYears * 12;
        for (let m = 1; m <= totalMonths; m++) {
            const date = new Date(this.config.startDate);
            date.setMonth(date.getMonth() + m);
            schedule.push({
                date,
                vestedShares: this.getVestedShares(date),
                exercisedShares: 0,
                remainingShares: this.config.shares - this.exercisedShares
            });
        }
        return schedule;
    }
}

// Example usage
const grantConfig: VestingConfig = {
    grantId: "GRANT-2024-001",
    shares: 10000,
    strikePrice: 0.50,
    startDate: new Date("2024-01-01"),
    vestingYears: 4,
    cliffYears: 1,
    dilutionRates: [0.15, 0.20, 0.25]
};

try {
    const tracker = new VestingTracker(grantConfig, true);
    const vested = tracker.getVestedShares(new Date("2025-01-01"));
    console.log(`Vested shares as of Jan 2025: ${vested}`);

    const exerciseEvent = tracker.exerciseShares(2500, new Date("2025-01-01"));
    console.log(`Exercised 2500 shares, cost: $${2500 * 0.50}`);

    const postDilution = tracker.getPostDilutionShares(3);
    console.log(`Post-dilution shares after 3 rounds: ${postDilution}`);
} catch (err) {
    console.error(`Vesting error: ${err instanceof Error ? err.message : err}`);
}

package main

import (
    "encoding/json"
    "errors"
    "fmt"
    "log"
    "math"
    "os"
    "time"
)

// CompensationPackage holds salary and equity details for comparison
type CompensationPackage struct {
    BaseSalary     float64 `json:"base_salary"`
    SignOnBonus    float64 `json:"sign_on_bonus"`
    EquityShares   int     `json:"equity_shares"`
    StrikePrice    float64 `json:"strike_price"`
    VestingYears   int     `json:"vesting_years"`
    CliffYears     int     `json:"cliff_years"`
    InflationRate  float64 `json:"inflation_rate"`  // Annual inflation rate (e.g., 0.03 for 3%)
    TaxRate        float64 `json:"tax_rate"`        // Combined federal/state tax rate (e.g., 0.32 for 32%)
    ExitMultiplier float64 `json:"exit_multiplier"` // Projected exit valuation multiple
    PreMoneyVal    float64 `json:"pre_money_val"`   // Pre-money valuation at exit ($)
}

// ComparatorError custom error type
type ComparatorError struct {
    Message string
}

func (e *ComparatorError) Error() string {
    return e.Message
}

// Validate checks that all package fields are valid
func (c *CompensationPackage) Validate() error {
    if c.BaseSalary <= 0 {
        return &ComparatorError{Message: "base_salary must be positive"}
    }
    if c.EquityShares < 0 {
        return &ComparatorError{Message: "equity_shares cannot be negative"}
    }
    if c.StrikePrice < 0 {
        return &ComparatorError{Message: "strike_price cannot be negative"}
    }
    if c.VestingYears <= 0 {
        return &ComparatorError{Message: "vesting_years must be positive"}
    }
    return nil
}

// CalculateTotalSalary returns after-tax salary + bonus over vesting period
func (c *CompensationPackage) CalculateTotalSalary() float64 {
    // Salary is paid annually, adjusted for inflation
    total := 0.0
    annualSalary := c.BaseSalary + (c.SignOnBonus / float64(c.VestingYears)) // Amortize sign-on over vesting
    for year := 0; year < c.VestingYears; year++ {
        inflationAdj := math.Pow(1+c.InflationRate, float64(year))
        taxedSalary := (annualSalary * inflationAdj) * (1 - c.TaxRate)
        total += taxedSalary
    }
    return total
}

// CalculateEquityValue returns net after-tax equity value at exit
func (c *CompensationPackage) CalculateEquityValue() (float64, error) {
    if c.EquityShares == 0 {
        return 0.0, nil
    }
    // Assume 1M shares outstanding, calculate share price at exit
    exitVal := c.PreMoneyVal * c.ExitMultiplier
    sharePriceExit := exitVal / 1_000_000 // 1M shares outstanding
    // Calculate post-dilution shares (assume 3 rounds: pre-seed, seed, A)
    dilutionRates := []float64{0.15, 0.20, 0.25}
    remainingShares := float64(c.EquityShares)
    for _, rate := range dilutionRates {
        remainingShares *= (1 - rate)
    }
    // Gross value minus exercise cost
    grossValue := remainingShares * sharePriceExit
    exerciseCost := float64(c.EquityShares) * c.StrikePrice
    // Tax on equity gains (long-term capital gains rate 20%)
    gain := grossValue - exerciseCost
    taxedGain := gain * 0.80 // 20% capital gains tax
    return taxedGain, nil
}

func main() {
    // Example package: Startup offer with $180k salary vs $160k + equity
    highSalaryPkg := CompensationPackage{
        BaseSalary:     180000,
        SignOnBonus:    20000,
        EquityShares:   8000,
        StrikePrice:    0.50,
        VestingYears:   4,
        CliffYears:     1,
        InflationRate:  0.03,
        TaxRate:        0.32,
        ExitMultiplier: 12.5,
        PreMoneyVal:    80_000_000,
    }

    equityHeavyPkg := CompensationPackage{
        BaseSalary:     160000,
        SignOnBonus:    10000,
        EquityShares:   12000,
        StrikePrice:    0.50,
        VestingYears:   4,
        CliffYears:     1,
        InflationRate:  0.03,
        TaxRate:        0.32,
        ExitMultiplier: 12.5,
        PreMoneyVal:    80_000_000,
    }

    packages := []CompensationPackage{highSalaryPkg, equityHeavyPkg}
    results := make([]map[string]interface{}, 0)

    for i, pkg := range packages {
        if err := pkg.Validate(); err != nil {
            log.Fatalf("Invalid package %d: %v", i, err)
        }

        salaryTotal := pkg.CalculateTotalSalary()
        equityTotal, err := pkg.CalculateEquityValue()
        if err != nil {
            log.Fatalf("Equity calculation failed for package %d: %v", i, err)
        }

        results = append(results, map[string]interface{}{
            "package_id":    i,
            "salary_total":  salaryTotal,
            "equity_total":  equityTotal,
            "total_comp":    salaryTotal + equityTotal,
            "base_salary":   pkg.BaseSalary,
            "equity_shares": pkg.EquityShares,
        })
    }

    // Output results as JSON
    jsonData, err := json.MarshalIndent(results, "", "  ")
    if err != nil {
        log.Fatalf("Failed to marshal JSON: %v", err)
    }

    fmt.Println(string(jsonData))

    // Compare packages
    pkg0Total := results[0]["total_comp"].(float64)
    pkg1Total := results[1]["total_comp"].(float64)
    diff := pkg1Total - pkg0Total
    fmt.Printf("\nEquity-heavy package outperforms high-salary by $%.2f (%.1f%%)\n", diff, (diff/pkg0Total)*100)
}