Intl Expansion

#!/usr/bin/env python3
"""Localization Checklist - Generate a phased localization checklist for a target market.

Creates a prioritized, phased checklist covering product, GTM, operations, and
compliance localization requirements for a specific target market.

Usage:
    python localization_checklist.py --market "Japan" --product-type saas --current-languages en
    python localization_checklist.py --market "Germany" --product-type saas --current-languages en,de --has-entity --json
"""

import argparse
import json
import sys
from datetime import datetime

MARKET_PROFILES = {
    "germany": {"region": "eu", "language": "German", "currency": "EUR", "data_privacy": "GDPR", "payment_methods": ["SEPA", "Giropay", "Credit Card"], "cultural_notes": "Enterprise-heavy, formal business culture, strong data privacy expectations", "entity_complexity": "medium", "timezone": "CET (UTC+1)"},
    "france": {"region": "eu", "language": "French", "currency": "EUR", "data_privacy": "GDPR", "payment_methods": ["Carte Bancaire", "SEPA", "Credit Card"], "cultural_notes": "Language required in business, strong labor laws, relationship-driven", "entity_complexity": "high", "timezone": "CET (UTC+1)"},
    "uk": {"region": "europe", "language": "English", "currency": "GBP", "data_privacy": "UK GDPR", "payment_methods": ["Direct Debit", "Credit Card"], "cultural_notes": "English-speaking, strong tech ecosystem, post-Brexit regulations", "entity_complexity": "low", "timezone": "GMT (UTC+0)"},
    "japan": {"region": "apac", "language": "Japanese", "currency": "JPY", "data_privacy": "APPI", "payment_methods": ["Konbini", "Bank Transfer", "Credit Card"], "cultural_notes": "Requires local partner, long sales cycles, relationship-heavy, high quality expectations", "entity_complexity": "very_high", "timezone": "JST (UTC+9)"},
    "singapore": {"region": "apac", "language": "English", "currency": "SGD", "data_privacy": "PDPA", "payment_methods": ["PayNow", "Credit Card", "Bank Transfer"], "cultural_notes": "Regional hub, English common, diverse market gateway to SEA", "entity_complexity": "low", "timezone": "SGT (UTC+8)"},
    "australia": {"region": "apac", "language": "English", "currency": "AUD", "data_privacy": "Privacy Act", "payment_methods": ["BPAY", "Direct Debit", "Credit Card"], "cultural_notes": "English-speaking, similar business culture, timezone challenge with US/EU", "entity_complexity": "low", "timezone": "AEST (UTC+10)"},
    "brazil": {"region": "latam", "language": "Portuguese", "currency": "BRL", "data_privacy": "LGPD", "payment_methods": ["Pix", "Boleto", "Credit Card"], "cultural_notes": "Portuguese required, complex tax system (Nota Fiscal), large opportunity", "entity_complexity": "very_high", "timezone": "BRT (UTC-3)"},
    "india": {"region": "apac", "language": "English/Hindi", "currency": "INR", "data_privacy": "DPDP Act", "payment_methods": ["UPI", "Net Banking", "Credit Card"], "cultural_notes": "Price-sensitive, English common in business, massive scale potential", "entity_complexity": "high", "timezone": "IST (UTC+5:30)"},
    "netherlands": {"region": "eu", "language": "Dutch/English", "currency": "EUR", "data_privacy": "GDPR", "payment_methods": ["iDEAL", "SEPA", "Credit Card"], "cultural_notes": "Multilingual, hub for European operations, direct communication style", "entity_complexity": "low", "timezone": "CET (UTC+1)"},
    "south_korea": {"region": "apac", "language": "Korean", "currency": "KRW", "data_privacy": "PIPA", "payment_methods": ["KakaoPay", "Bank Transfer", "Credit Card"], "cultural_notes": "Tech-savvy, relationship-important, hierarchical business culture", "entity_complexity": "high", "timezone": "KST (UTC+9)"},
}

def get_market_profile(market_name):
    key = market_name.lower().replace(" ", "_")
    if key in MARKET_PROFILES:
        return MARKET_PROFILES[key]
    # Default profile for unknown markets
    return {
        "region": "unknown", "language": "Local language", "currency": "Local currency",
        "data_privacy": "Research required", "payment_methods": ["Credit Card", "Local methods TBD"],
        "cultural_notes": "Research local business culture before entry",
        "entity_complexity": "unknown", "timezone": "Research required"
    }


def generate_checklist(market_name, product_type, current_languages, has_entity, arr_from_market):
    profile = get_market_profile(market_name)
    needs_translation = profile["language"].split("/")[0].lower() not in [l.lower() for l in current_languages]

    checklist = {
        "generated_date": datetime.now().strftime("%Y-%m-%d"),
        "market": market_name,
        "market_profile": profile,
        "product_type": product_type,
        "current_languages": current_languages,
        "has_entity": has_entity,
        "translation_needed": needs_translation,
        "phases": []
    }

    # Phase 1: Must Have (Pre-Launch)
    phase1_items = []
    if needs_translation:
        phase1_items.append({"item": f"Translate core product UI to {profile['language']}", "category": "product", "priority": "must-have", "est_cost": "$20-50K", "timeline": "4-8 weeks"})
    phase1_items.append({"item": f"Support {profile['currency']} currency display and charging", "category": "product", "priority": "must-have", "est_cost": "$10-30K", "timeline": "2-4 weeks"})
    phase1_items.append({"item": f"Integrate local payment method: {profile['payment_methods'][0]}", "category": "product", "priority": "must-have", "est_cost": "$5-20K", "timeline": "2-4 weeks"})
    phase1_items.append({"item": "Localize date, time, number, and address formats", "category": "product", "priority": "must-have", "est_cost": "$5-15K", "timeline": "1-2 weeks"})
    phase1_items.append({"item": f"Ensure {profile['data_privacy']} compliance for data handling", "category": "compliance", "priority": "must-have", "est_cost": "$10-50K", "timeline": "4-8 weeks"})
    phase1_items.append({"item": "Review and adapt contracts for local legal requirements", "category": "legal", "priority": "must-have", "est_cost": "$10-30K", "timeline": "3-6 weeks"})
    phase1_items.append({"item": f"Adapt value proposition for {market_name} market pain points", "category": "gtm", "priority": "must-have", "est_cost": "$5-15K", "timeline": "2-4 weeks"})
    phase1_items.append({"item": f"Research and document local ICP definition for {market_name}", "category": "gtm", "priority": "must-have", "est_cost": "$5-10K", "timeline": "2-3 weeks"})
    phase1_items.append({"item": f"Set market-specific pricing based on local willingness to pay", "category": "gtm", "priority": "must-have", "est_cost": "Internal effort", "timeline": "2-3 weeks"})

    if not has_entity and arr_from_market >= 500000:
        phase1_items.append({"item": f"Establish legal entity in {market_name}", "category": "legal", "priority": "must-have", "est_cost": "$50-200K", "timeline": "8-16 weeks"})
    elif not has_entity and arr_from_market >= 200000:
        phase1_items.append({"item": f"Hire first local person via EOR (Employer of Record)", "category": "people", "priority": "must-have", "est_cost": "$100-300K/year", "timeline": "4-8 weeks"})

    checklist["phases"].append({"phase": 1, "name": "Must Have (Pre-Launch)", "items": phase1_items})

    # Phase 2: Nice to Have (Post-Launch, Revenue-Gated)
    phase2_items = []
    if needs_translation:
        phase2_items.append({"item": f"Translate marketing website to {profile['language']}", "category": "gtm", "priority": "nice-to-have", "est_cost": "$10-25K", "timeline": "3-6 weeks"})
    phase2_items.append({"item": f"Integrate additional payment methods: {', '.join(profile['payment_methods'][1:])}", "category": "product", "priority": "nice-to-have", "est_cost": "$5-20K per method", "timeline": "2-4 weeks each"})
    phase2_items.append({"item": "Create local customer case studies and references", "category": "gtm", "priority": "nice-to-have", "est_cost": "$5-10K", "timeline": "4-8 weeks"})
    phase2_items.append({"item": f"Build local SEO content in {profile['language']}", "category": "gtm", "priority": "nice-to-have", "est_cost": "$10-20K", "timeline": "Ongoing"})
    phase2_items.append({"item": "Establish local partner/integration ecosystem", "category": "gtm", "priority": "nice-to-have", "est_cost": "Partnership effort", "timeline": "3-6 months"})
    phase2_items.append({"item": f"Set up customer support coverage for {profile['timezone']}", "category": "operations", "priority": "nice-to-have", "est_cost": "$50-100K/year", "timeline": "4-8 weeks"})

    checklist["phases"].append({"phase": 2, "name": "Nice to Have (Revenue-Gated)", "items": phase2_items})

    # Phase 3: Scale (After proven market)
    phase3_items = []
    if profile.get("entity_complexity") in ["high", "very_high"] and not has_entity:
        phase3_items.append({"item": f"Establish full legal entity with local banking", "category": "legal", "priority": "scale", "est_cost": "$100K-500K", "timeline": "8-20 weeks"})
    phase3_items.append({"item": "Hire regional leadership (Country Manager or Regional VP)", "category": "people", "priority": "scale", "est_cost": "$150-250K/year", "timeline": "8-12 weeks"})
    phase3_items.append({"item": "Build local team (3-8 people across sales, CS, marketing)", "category": "people", "priority": "scale", "est_cost": "$500K-1.5M/year", "timeline": "3-6 months"})
    phase3_items.append({"item": "Develop market-specific product features based on local feedback", "category": "product", "priority": "scale", "est_cost": "Engineering allocation", "timeline": "Ongoing"})
    phase3_items.append({"item": "Attend regional conferences and events", "category": "gtm", "priority": "scale", "est_cost": "$20-50K/year", "timeline": "Ongoing"})

    checklist["phases"].append({"phase": 3, "name": "Scale (After Market Validation)", "items": phase3_items})

    # Calculate totals
    total_must_have = len(phase1_items)
    total_items = sum(len(p["items"]) for p in checklist["phases"])

    checklist["summary"] = {
        "total_items": total_items,
        "must_have_items": total_must_have,
        "translation_needed": needs_translation,
        "entity_needed": not has_entity and arr_from_market >= 500000,
        "cultural_notes": profile["cultural_notes"]
    }

    return checklist


def print_human(result):
    print(f"\n{'='*70}")
    print(f"LOCALIZATION CHECKLIST: {result['market']}")
    print(f"Generated: {result['generated_date']}")
    print(f"{'='*70}\n")

    p = result["market_profile"]
    print(f"MARKET PROFILE:")
    print(f"  Language: {p['language']}  |  Currency: {p['currency']}  |  Timezone: {p['timezone']}")
    print(f"  Data Privacy: {p['data_privacy']}  |  Entity Complexity: {p['entity_complexity']}")
    print(f"  Cultural Notes: {p['cultural_notes']}\n")

    for phase in result["phases"]:
        print(f"\n--- PHASE {phase['phase']}: {phase['name']} ---")
        for item in phase["items"]:
            print(f"  [ ] [{item['category']:<10s}] {item['item']}")
            print(f"       Cost: {item['est_cost']}  |  Timeline: {item['timeline']}")

    s = result["summary"]
    print(f"\nSUMMARY: {s['total_items']} total items, {s['must_have_items']} must-have")
    print(f"  Translation needed: {'Yes' if s['translation_needed'] else 'No'}")
    print(f"  Entity needed: {'Yes' if s['entity_needed'] else 'No'}")
    print()


def main():
    parser = argparse.ArgumentParser(description="Generate phased localization checklist")
    parser.add_argument("--market", required=True, help="Target market name")
    parser.add_argument("--product-type", default="saas", choices=["saas", "marketplace", "hardware", "services"])
    parser.add_argument("--current-languages", default="en", help="Comma-separated current supported languages")
    parser.add_argument("--has-entity", action="store_true", help="Already have legal entity in market")
    parser.add_argument("--arr-from-market", type=float, default=0, help="Current ARR from this market")
    parser.add_argument("--json", action="store_true", help="Output as JSON")
    args = parser.parse_args()

    languages = [l.strip() for l in args.current_languages.split(",")]
    result = generate_checklist(args.market, args.product_type, languages, args.has_entity, args.arr_from_market)

    if args.json:
        print(json.dumps(result, indent=2))
    else:
        print_human(result)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Market Readiness Scorer - Score and rank target markets using 6-factor weighted framework.

Evaluates international markets on market size, competitive intensity, regulatory
complexity, cultural distance, existing traction, and operational complexity.
Produces a weighted score with go/no-go recommendation.

Usage:
    python market_readiness_scorer.py --market "Germany" --market-size 4 --competition 3 --regulatory 2 --cultural-distance 3 --traction 4 --operational 3
    python market_readiness_scorer.py --market "Japan" --market-size 5 --competition 2 --regulatory 1 --cultural-distance 1 --traction 2 --operational 2 --json
    python market_readiness_scorer.py compare --markets markets.csv --json
"""

import argparse
import json
import sys
from datetime import datetime

FACTORS = {
    "market_size": {
        "name": "Market Size (Addressable)",
        "weight": 0.25,
        "description": "TAM in target segment, willingness to pay, growth rate",
        "scoring_guide": {
            5: "Very large addressable market with proven willingness to pay",
            4: "Large market with good growth rate",
            3: "Medium market, adequate for regional presence",
            2: "Small market, niche opportunity only",
            1: "Minimal addressable market"
        }
    },
    "competition": {
        "name": "Competitive Intensity",
        "weight": 0.20,
        "description": "Incumbent strength, number of alternatives, market gaps",
        "scoring_guide": {
            5: "Few competitors, clear market gap for your offering",
            4: "Moderate competition with differentiable positioning",
            3: "Several competitors but room for new entrants",
            2: "Strong incumbents with established market share",
            1: "Dominant incumbents, extremely hard to penetrate"
        }
    },
    "regulatory": {
        "name": "Regulatory Complexity",
        "weight": 0.20,
        "description": "Barriers to entry, compliance cost, timeline to launch",
        "scoring_guide": {
            5: "Minimal regulatory barriers, fast to launch",
            4: "Light regulation, manageable compliance",
            3: "Moderate regulation, requires legal counsel",
            2: "Heavy regulation, significant compliance investment",
            1: "Extreme regulation, data localization required, long timeline"
        }
    },
    "cultural_distance": {
        "name": "Cultural Distance",
        "weight": 0.15,
        "description": "Language, business practices, buying behavior, sales cycle",
        "scoring_guide": {
            5: "Very similar culture, English-speaking, familiar business practices",
            4: "Low cultural distance, English common in business",
            3: "Moderate cultural adaptation needed, local language helpful",
            2: "Significant cultural differences, local language required",
            1: "Very high cultural distance, local partner essential"
        }
    },
    "traction": {
        "name": "Existing Traction",
        "weight": 0.10,
        "description": "Inbound demand, existing customers, partnership signals",
        "scoring_guide": {
            5: "Strong inbound demand, multiple existing customers",
            4: "Some inbound interest, 1-2 existing customers",
            3: "Partnership signals or adjacent market success",
            2: "Minimal traction, mostly push-driven interest",
            1: "No existing traction or signals"
        }
    },
    "operational": {
        "name": "Operational Complexity",
        "weight": 0.10,
        "description": "Time zones, infrastructure, payment systems, talent pool",
        "scoring_guide": {
            5: "Easy operations: good timezone overlap, strong infrastructure",
            4: "Manageable operations with minor adjustments",
            3: "Moderate complexity: timezone gaps, some infrastructure needs",
            2: "Significant operational challenges",
            1: "Very challenging: extreme timezone, poor infrastructure, limited talent"
        }
    }
}

ENTRY_RECOMMENDATIONS = {
    "strong_go": {"min_score": 4.0, "label": "STRONG GO", "recommendation": "Market shows strong signals. Proceed with entry planning. Consider Local Hire or Full Entity based on existing revenue."},
    "go": {"min_score": 3.2, "label": "GO", "recommendation": "Market is viable. Start with Remote Sales to validate demand before committing resources."},
    "conditional": {"min_score": 2.5, "label": "CONDITIONAL", "recommendation": "Market has potential but significant risks. Validate with 20+ discovery calls before any investment. Define strict exit criteria."},
    "no_go": {"min_score": 0, "label": "NO GO", "recommendation": "Market does not score high enough to justify investment. Focus resources on stronger markets."}
}


def score_market(market_name, scores):
    weighted_total = 0.0
    factor_results = []

    for factor_key, factor_info in FACTORS.items():
        score = scores.get(factor_key, 3)
        weighted = score * factor_info["weight"]
        weighted_total += weighted

        factor_results.append({
            "factor": factor_info["name"],
            "key": factor_key,
            "score": score,
            "weight": factor_info["weight"],
            "weighted_score": round(weighted, 2),
            "description": factor_info["scoring_guide"].get(score, "")
        })

    overall = round(weighted_total, 2)

    # Determine recommendation
    recommendation = ENTRY_RECOMMENDATIONS["no_go"]
    for rec_key in ["strong_go", "go", "conditional", "no_go"]:
        if overall >= ENTRY_RECOMMENDATIONS[rec_key]["min_score"]:
            recommendation = ENTRY_RECOMMENDATIONS[rec_key]
            break

    # Identify risks (scores 1-2)
    risks = [f for f in factor_results if f["score"] <= 2]

    # Identify strengths (scores 4-5)
    strengths = [f for f in factor_results if f["score"] >= 4]

    # Entry mode recommendation based on traction
    traction_score = scores.get("traction", 3)
    if traction_score >= 4:
        entry_mode = "Local Hire (EOR) or Full Entity -- existing traction justifies investment"
    elif traction_score >= 3:
        entry_mode = "Remote Sales for 3-6 months, then evaluate Local Hire"
    else:
        entry_mode = "Remote Sales only -- prove demand before any local investment"

    return {
        "assessment_date": datetime.now().strftime("%Y-%m-%d"),
        "market": market_name,
        "overall_score": overall,
        "max_possible": 5.0,
        "recommendation": recommendation["label"],
        "recommendation_detail": recommendation["recommendation"],
        "entry_mode_suggestion": entry_mode,
        "factor_scores": factor_results,
        "strengths": [{"factor": s["factor"], "score": s["score"]} for s in strengths],
        "risks": [{"factor": r["factor"], "score": r["score"], "description": r["description"]} for r in risks],
        "next_steps": [
            f"Validate traction with 20+ discovery calls in {market_name}",
            f"Engage local legal counsel for regulatory assessment" if scores.get("regulatory", 3) <= 3 else f"Regulatory environment is manageable",
            f"Research local competitors and positioning gaps",
            f"Define 12-month exit criteria: pipeline > $500K, revenue > $200K ARR"
        ]
    }


def print_human(result):
    print(f"\n{'='*70}")
    print(f"MARKET READINESS SCORE: {result['market']}")
    print(f"Date: {result['assessment_date']}")
    print(f"{'='*70}\n")

    print(f"OVERALL SCORE: {result['overall_score']}/{result['max_possible']}")
    print(f"RECOMMENDATION: {result['recommendation']}")
    print(f"  {result['recommendation_detail']}\n")

    print(f"ENTRY MODE: {result['entry_mode_suggestion']}\n")

    print("FACTOR SCORES:")
    print("-" * 60)
    for f in result["factor_scores"]:
        bar = "#" * f["score"] + "." * (5 - f["score"])
        print(f"  {f['factor']:<30s} {f['score']}/5  [{bar}]  (weight: {f['weight']})")

    if result["strengths"]:
        print(f"\nSTRENGTHS:")
        for s in result["strengths"]:
            print(f"  [+] {s['factor']}: {s['score']}/5")

    if result["risks"]:
        print(f"\nRISKS:")
        for r in result["risks"]:
            print(f"  [!] {r['factor']}: {r['score']}/5 -- {r['description']}")

    print(f"\nNEXT STEPS:")
    for n in result["next_steps"]:
        print(f"  -> {n}")
    print()


def main():
    parser = argparse.ArgumentParser(description="Score and rank target markets for international expansion")
    parser.add_argument("--market", required=True, help="Market name (e.g., 'Germany', 'Japan')")
    parser.add_argument("--market-size", type=int, required=True, choices=[1,2,3,4,5], help="Market size score (1-5)")
    parser.add_argument("--competition", type=int, required=True, choices=[1,2,3,4,5], help="Competitive intensity score (1-5, 5=favorable)")
    parser.add_argument("--regulatory", type=int, required=True, choices=[1,2,3,4,5], help="Regulatory complexity (1-5, 5=easy)")
    parser.add_argument("--cultural-distance", type=int, required=True, choices=[1,2,3,4,5], help="Cultural distance (1-5, 5=close)")
    parser.add_argument("--traction", type=int, required=True, choices=[1,2,3,4,5], help="Existing traction (1-5)")
    parser.add_argument("--operational", type=int, required=True, choices=[1,2,3,4,5], help="Operational complexity (1-5, 5=easy)")
    parser.add_argument("--json", action="store_true", help="Output as JSON")
    args = parser.parse_args()

    scores = {
        "market_size": args.market_size,
        "competition": args.competition,
        "regulatory": args.regulatory,
        "cultural_distance": args.cultural_distance,
        "traction": args.traction,
        "operational": args.operational
    }

    result = score_market(args.market, scores)

    if args.json:
        print(json.dumps(result, indent=2))
    else:
        print_human(result)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Regulatory Mapper - Map regulatory requirements by region for international expansion.

Maps data privacy, tax, employment law, and industry-specific regulatory requirements
for target regions. Provides compliance checklist with estimated cost and timeline.

Usage:
    python regulatory_mapper.py --region eu --industry saas --data-processing yes
    python regulatory_mapper.py --region apac --industry healthtech --data-processing yes --json
"""

import argparse
import json
import sys
from datetime import datetime

REGULATIONS = {
    "eu": {
        "region_name": "European Union",
        "data_privacy": {
            "regulation": "GDPR (General Data Protection Regulation)",
            "key_requirements": [
                "Lawful basis for processing (consent, legitimate interest, contract, etc.)",
                "Data Protection Officer (DPO) required if processing at scale",
                "72-hour breach notification to supervisory authority",
                "Data Protection Impact Assessment for high-risk processing",
                "Right to erasure, portability, and access for data subjects",
                "Cross-border transfer rules (SCCs or adequacy decisions)",
                "Data minimization and purpose limitation",
                "Records of processing activities"
            ],
            "penalty": "Up to 4% of annual global revenue or EUR 20M (whichever is greater)",
            "timeline_to_comply": "3-6 months for initial compliance",
            "estimated_cost": "$50K-200K initial; $20K-50K annual maintenance"
        },
        "tax": {
            "requirements": [
                "VAT registration required (threshold varies by country)",
                "OSS (One-Stop Shop) for B2C digital services",
                "Transfer pricing documentation for intercompany transactions",
                "Permanent establishment risk assessment",
                "Country-by-country reporting if revenue > EUR 750M"
            ],
            "vat_rate_range": "17-27% (varies by country)",
            "estimated_cost": "$20K-50K setup; $10K-30K annual compliance"
        },
        "employment": {
            "key_rules": [
                "Strong employee protections (notice periods 1-6 months)",
                "Works council requirements in some countries (Germany, France, Netherlands)",
                "Mandatory benefits (pension, health, vacation minimum 20-25 days)",
                "Anti-discrimination and equal pay regulations",
                "Remote work regulations vary by country",
                "Probation period limitations (typically 3-6 months)"
            ],
            "hiring_options": ["Direct employment (requires entity)", "EOR (Employer of Record)", "Contractor (limited, risk of misclassification)"],
            "estimated_cost": "30-50% on top of salary for mandatory benefits"
        },
        "entity": {
            "common_types": ["GmbH (Germany)", "SAS (France)", "BV (Netherlands)", "Ltd (Ireland)"],
            "timeline": "4-12 weeks depending on country",
            "estimated_cost": "$15K-50K setup; $10K-30K annual maintenance"
        }
    },
    "uk": {
        "region_name": "United Kingdom",
        "data_privacy": {
            "regulation": "UK GDPR + Data Protection Act 2018",
            "key_requirements": [
                "Similar to EU GDPR with UK-specific adaptations",
                "ICO registration required",
                "UK representative required if no UK establishment",
                "International data transfer mechanisms (UK SCCs, adequacy)",
                "Breach notification within 72 hours to ICO"
            ],
            "penalty": "Up to 4% of annual global revenue or GBP 17.5M",
            "timeline_to_comply": "2-4 months (faster if already GDPR compliant)",
            "estimated_cost": "$20K-80K initial; $10K-25K annual"
        },
        "tax": {
            "requirements": [
                "VAT registration (threshold GBP 85K for UK establishments)",
                "Corporation tax on UK-sourced profits",
                "Transfer pricing documentation",
                "Digital Services Tax (2%) on UK-derived revenue > GBP 25M"
            ],
            "vat_rate_range": "20% standard rate",
            "estimated_cost": "$15K-30K setup; $10K-20K annual"
        },
        "employment": {
            "key_rules": [
                "Statutory notice periods (1 week per year of service, up to 12 weeks)",
                "28 days minimum holiday (including bank holidays)",
                "Statutory sick pay requirements",
                "Auto-enrollment pension contribution",
                "National Insurance contributions",
                "IR35 rules for contractor engagement"
            ],
            "hiring_options": ["Direct employment (entity required)", "EOR", "Contractor (IR35 compliance critical)"],
            "estimated_cost": "15-25% on top of salary for mandatory benefits"
        },
        "entity": {
            "common_types": ["Ltd (Private Limited Company)"],
            "timeline": "1-2 weeks (very fast)",
            "estimated_cost": "$5K-15K setup; $5K-15K annual maintenance"
        }
    },
    "apac": {
        "region_name": "Asia-Pacific (General)",
        "data_privacy": {
            "regulation": "Varies: APPI (Japan), PDPA (Singapore), Privacy Act (Australia), PIPA (South Korea), DPDP (India)",
            "key_requirements": [
                "Consent requirements vary significantly by country",
                "Data localization requirements in some jurisdictions (China, India partial)",
                "Cross-border transfer restrictions vary",
                "Breach notification requirements vary (24hrs-72hrs depending on country)",
                "Data Protection Officer requirements vary",
                "Japan: APPI requires purpose specification and consent for third-party sharing",
                "Singapore: PDPA requires consent with business contact exception",
                "Australia: APPs with mandatory breach notification"
            ],
            "penalty": "Varies significantly: Japan (criminal penalties possible), Singapore (up to S$1M), Australia (increasing penalties)",
            "timeline_to_comply": "3-9 months depending on country",
            "estimated_cost": "$30K-150K initial; $15K-50K annual per country"
        },
        "tax": {
            "requirements": [
                "GST/Consumption tax registration varies by country",
                "Withholding tax on cross-border payments common",
                "Transfer pricing documentation required in most jurisdictions",
                "Permanent establishment rules vary significantly",
                "Japan: Consumption tax 10%, complex compliance",
                "Singapore: GST 9%, relatively straightforward",
                "Australia: GST 10%, BAS quarterly reporting"
            ],
            "vat_rate_range": "5-10% (varies by country)",
            "estimated_cost": "$20K-60K setup per country; $15K-40K annual"
        },
        "employment": {
            "key_rules": [
                "Employee protections vary: strong in Japan/Korea, moderate in Singapore/Australia",
                "Notice periods: Japan (30 days), Singapore (1-3 months), Australia (1-5 weeks)",
                "Mandatory benefits vary significantly by country",
                "Japan: lifetime employment culture, termination extremely difficult",
                "Singapore: flexible labor laws, Central Provident Fund contributions",
                "Australia: Fair Work Act, modern awards system, superannuation (11.5%)"
            ],
            "hiring_options": ["Direct employment (entity required)", "EOR (recommended for first hires)", "Contractor (rules vary by country)"],
            "estimated_cost": "15-40% on top of salary depending on country"
        },
        "entity": {
            "common_types": ["KK/GK (Japan)", "Pte Ltd (Singapore)", "Pty Ltd (Australia)"],
            "timeline": "2-16 weeks depending on country (Japan longest)",
            "estimated_cost": "$10K-100K setup; $10K-50K annual depending on country"
        }
    },
    "latam": {
        "region_name": "Latin America",
        "data_privacy": {
            "regulation": "LGPD (Brazil), various others developing",
            "key_requirements": [
                "Brazil LGPD: similar to GDPR, DPO required",
                "Consent as primary legal basis (Brazil)",
                "Data subject rights: access, correction, deletion, portability",
                "Cross-border transfer restrictions",
                "Breach notification to ANPD (Brazil)",
                "Mexico: LFPDPPP for private sector data protection",
                "Argentina: Personal Data Protection Law (EU adequacy)"
            ],
            "penalty": "Brazil: up to 2% of revenue, capped at R$50M per violation",
            "timeline_to_comply": "3-6 months",
            "estimated_cost": "$30K-100K initial; $15K-40K annual"
        },
        "tax": {
            "requirements": [
                "Brazil: extremely complex tax system (Nota Fiscal, ICMS, ISS, PIS/COFINS)",
                "Withholding taxes on cross-border service payments (15-25%)",
                "Transfer pricing rules in most countries",
                "Brazil: requires local tax representative for foreign companies",
                "Mexico: VAT 16%, withholding on digital services",
                "Argentina: complex FX controls and tax regulations"
            ],
            "vat_rate_range": "16-21% (varies by country)",
            "estimated_cost": "$30K-80K setup; $20K-50K annual (Brazil highest)"
        },
        "employment": {
            "key_rules": [
                "Strong employee protections across the region",
                "Brazil: CLT (labor code), 13th salary, FGTS, extensive termination costs",
                "Mexico: profit sharing (10%), severance (3 months + 20 days per year)",
                "Mandatory benefits typically 60-100% on top of salary",
                "Termination extremely costly in Brazil and Mexico"
            ],
            "hiring_options": ["EOR (strongly recommended for first hires)", "Direct employment (entity required)", "Contractor (high misclassification risk)"],
            "estimated_cost": "60-100% on top of salary for mandatory benefits (Brazil/Mexico)"
        },
        "entity": {
            "common_types": ["Ltda (Brazil)", "S de RL de CV (Mexico)", "SAS (Colombia)"],
            "timeline": "8-20 weeks (Brazil and Mexico longest)",
            "estimated_cost": "$20K-80K setup; $15K-40K annual"
        }
    }
}

INDUSTRY_OVERLAYS = {
    "saas": {
        "additional_requirements": [
            "Digital services tax applicability assessment",
            "SaaS-specific data processing agreements",
            "Service availability SLA commitments",
            "Data portability on contract termination"
        ]
    },
    "healthtech": {
        "additional_requirements": [
            "Health data classification and special category data rules",
            "Medical device regulation assessment (EU MDR if applicable)",
            "HIPAA-equivalent local health data regulations",
            "Clinical data storage and processing requirements",
            "Health authority registration if applicable"
        ]
    },
    "fintech": {
        "additional_requirements": [
            "Financial services licensing requirements",
            "Anti-money laundering (AML) and KYC compliance",
            "Payment services regulation (PSD2 in EU)",
            "Capital adequacy requirements if applicable",
            "Regulatory sandbox availability"
        ]
    },
    "edtech": {
        "additional_requirements": [
            "Student data protection (COPPA equivalent)",
            "Educational content localization requirements",
            "Accessibility compliance (WCAG)",
            "Institutional procurement requirements"
        ]
    }
}


def map_regulations(region, industry, data_processing):
    region_key = region.lower()
    if region_key not in REGULATIONS:
        print(f"Error: Unknown region '{region}'. Available: {', '.join(REGULATIONS.keys())}", file=sys.stderr)
        sys.exit(1)

    reg = REGULATIONS[region_key]
    industry_overlay = INDUSTRY_OVERLAYS.get(industry.lower(), {"additional_requirements": []})

    # Build compliance checklist
    checklist = []
    checklist.append({"category": "Data Privacy", "items": reg["data_privacy"]["key_requirements"], "regulation": reg["data_privacy"]["regulation"], "penalty": reg["data_privacy"]["penalty"], "timeline": reg["data_privacy"]["timeline_to_comply"], "cost": reg["data_privacy"]["estimated_cost"]})
    checklist.append({"category": "Tax Compliance", "items": reg["tax"]["requirements"], "cost": reg["tax"]["estimated_cost"]})
    checklist.append({"category": "Employment Law", "items": reg["employment"]["key_rules"], "hiring_options": reg["employment"]["hiring_options"], "cost": reg["employment"]["estimated_cost"]})
    checklist.append({"category": "Entity Formation", "items": [f"Entity types: {', '.join(reg['entity']['common_types'])}", f"Timeline: {reg['entity']['timeline']}"], "cost": reg["entity"]["estimated_cost"]})

    if industry_overlay["additional_requirements"]:
        checklist.append({"category": f"Industry-Specific ({industry.title()})", "items": industry_overlay["additional_requirements"]})

    return {
        "map_date": datetime.now().strftime("%Y-%m-%d"),
        "region": reg["region_name"],
        "region_key": region_key,
        "industry": industry,
        "data_processing": data_processing,
        "regulatory_summary": {
            "data_privacy": reg["data_privacy"]["regulation"],
            "max_penalty": reg["data_privacy"]["penalty"],
            "entity_complexity": reg["entity"]["timeline"],
            "employment_cost_overhead": reg["employment"]["estimated_cost"]
        },
        "compliance_checklist": checklist,
        "risk_assessment": {
            "data_privacy_risk": "HIGH" if data_processing else "MEDIUM",
            "employment_risk": "HIGH" if region_key in ["latam", "eu"] else "MEDIUM",
            "tax_complexity": "VERY HIGH" if region_key == "latam" else "HIGH" if region_key in ["eu", "apac"] else "MEDIUM",
            "entity_timeline": reg["entity"]["timeline"]
        },
        "recommendations": [
            f"Engage local legal counsel in {reg['region_name']} before committing resources",
            f"Budget for {reg['data_privacy']['estimated_cost']} for data privacy compliance",
            f"Consider EOR for first hires to avoid entity setup delay",
            f"Start regulatory assessment at T-90 days before planned launch"
        ]
    }


def print_human(result):
    print(f"\n{'='*70}")
    print(f"REGULATORY MAP: {result['region']}")
    print(f"Industry: {result['industry']}  |  Data Processing: {result['data_processing']}")
    print(f"Date: {result['map_date']}")
    print(f"{'='*70}\n")

    rs = result["regulatory_summary"]
    print(f"SUMMARY:")
    print(f"  Data Privacy: {rs['data_privacy']}")
    print(f"  Max Penalty: {rs['max_penalty']}")
    print(f"  Entity Timeline: {rs['entity_complexity']}")
    print(f"  Employment Overhead: {rs['employment_cost_overhead']}\n")

    for section in result["compliance_checklist"]:
        print(f"\n--- {section['category'].upper()} ---")
        if "regulation" in section:
            print(f"  Regulation: {section['regulation']}")
        if "penalty" in section:
            print(f"  Penalty: {section['penalty']}")
        for item in section["items"]:
            print(f"  [ ] {item}")
        if "cost" in section:
            print(f"  Estimated Cost: {section['cost']}")

    ra = result["risk_assessment"]
    print(f"\nRISK ASSESSMENT:")
    print(f"  Data Privacy: {ra['data_privacy_risk']}")
    print(f"  Employment: {ra['employment_risk']}")
    print(f"  Tax Complexity: {ra['tax_complexity']}")

    print(f"\nRECOMMENDATIONS:")
    for r in result["recommendations"]:
        print(f"  -> {r}")
    print()


def main():
    parser = argparse.ArgumentParser(description="Map regulatory requirements by region")
    parser.add_argument("--region", required=True, choices=list(REGULATIONS.keys()), help="Target region")
    parser.add_argument("--industry", default="saas", choices=list(INDUSTRY_OVERLAYS.keys()) + ["other"], help="Industry")
    parser.add_argument("--data-processing", default="yes", choices=["yes", "no"], help="Does the product process personal data?")
    parser.add_argument("--json", action="store_true", help="Output as JSON")
    args = parser.parse_args()

    result = map_regulations(args.region, args.industry, args.data_processing == "yes")

    if args.json:
        print(json.dumps(result, indent=2))
    else:
        print_human(result)


if __name__ == "__main__":
    main()