Solutions Architect

#!/usr/bin/env python3
"""Score proposed solution architectures against requirements and best practices.

Evaluates architecture proposals across dimensions: scalability, security,
integration complexity, maintainability, performance, and compliance.
Produces an overall fitness score with gap analysis.

Usage:
    python architecture_scorer.py --data architecture.json
    python architecture_scorer.py --data architecture.csv --json
    python architecture_scorer.py --data architecture.json --threshold 70
"""

import argparse
import csv
import json
import os
import sys
from datetime import datetime


DIMENSIONS = {
    "scalability": {
        "weight": 0.20,
        "fields": ["horizontal_scaling", "auto_scaling", "load_balancing", "data_partitioning"],
        "description": "Ability to handle growth in users, data, and transactions",
    },
    "security": {
        "weight": 0.20,
        "fields": ["authentication", "authorization", "encryption", "audit_logging"],
        "description": "Security posture across auth, data protection, and compliance",
    },
    "integration": {
        "weight": 0.15,
        "fields": ["api_design", "event_driven", "data_consistency", "error_handling"],
        "description": "Integration architecture quality and patterns",
    },
    "reliability": {
        "weight": 0.15,
        "fields": ["high_availability", "disaster_recovery", "monitoring", "failover"],
        "description": "System reliability, uptime, and recovery capabilities",
    },
    "performance": {
        "weight": 0.15,
        "fields": ["response_time", "throughput", "caching", "optimization"],
        "description": "Performance characteristics and efficiency",
    },
    "maintainability": {
        "weight": 0.15,
        "fields": ["modularity", "documentation", "deployment", "testing"],
        "description": "Ease of maintenance, updates, and operational management",
    },
}

SCORE_LABELS = {
    (0, 40): ("Inadequate", "Architecture has critical gaps. Requires significant redesign."),
    (40, 55): ("Below Standard", "Notable deficiencies. Address gaps before customer presentation."),
    (55, 70): ("Acceptable", "Meets minimum requirements. Strengthen weak areas."),
    (70, 85): ("Strong", "Well-designed architecture. Minor improvements possible."),
    (85, 101): ("Excellent", "Enterprise-grade architecture. Ready for customer presentation."),
}

COMPLIANCE_FRAMEWORKS = {
    "soc2": ["encryption", "audit_logging", "authentication", "authorization", "monitoring"],
    "hipaa": ["encryption", "audit_logging", "authentication", "authorization", "data_partitioning"],
    "gdpr": ["encryption", "data_partitioning", "audit_logging", "documentation"],
    "pci_dss": ["encryption", "authentication", "audit_logging", "monitoring", "failover"],
    "fedramp": ["encryption", "authentication", "authorization", "audit_logging", "monitoring", "disaster_recovery"],
}


def load_data(filepath):
    """Load architecture data from CSV or JSON file."""
    ext = os.path.splitext(filepath)[1].lower()
    if ext == ".json":
        with open(filepath, "r") as f:
            data = json.load(f)
            return data if isinstance(data, list) else [data]
    elif ext == ".csv":
        with open(filepath, "r") as f:
            return list(csv.DictReader(f))
    else:
        print(f"Error: Unsupported file format '{ext}'. Use .csv or .json.", file=sys.stderr)
        sys.exit(1)


def parse_score(value, max_val=10):
    """Parse a score value, clamping to 0-max_val."""
    try:
        score = float(value)
        return max(0, min(score, max_val))
    except (ValueError, TypeError):
        return 0


def score_architecture(arch):
    """Score a single architecture proposal."""
    name = arch.get("name", arch.get("project", arch.get("customer", "Unknown")))
    arch_type = arch.get("type", arch.get("architecture_type", "Custom"))
    target_compliance = arch.get("compliance", arch.get("compliance_framework", "")).lower().strip()

    dimension_results = {}
    total_weighted = 0

    for dim_name, dim_config in DIMENSIONS.items():
        field_scores = {}
        for field in dim_config["fields"]:
            raw = arch.get(field, arch.get(f"{dim_name}_{field}", 0))
            field_scores[field] = parse_score(raw, 10)

        populated = sum(1 for v in field_scores.values() if v > 0)
        avg_score = sum(field_scores.values()) / len(dim_config["fields"]) if dim_config["fields"] else 0
        weighted = avg_score * dim_config["weight"]
        total_weighted += weighted

        weak_fields = [f for f, s in field_scores.items() if s < 5]
        strong_fields = [f for f, s in field_scores.items() if s >= 8]

        dimension_results[dim_name] = {
            "score": round(avg_score, 2),
            "weight": dim_config["weight"],
            "weighted_contribution": round(weighted, 2),
            "description": dim_config["description"],
            "field_scores": field_scores,
            "fields_populated": populated,
            "weak_fields": weak_fields,
            "strong_fields": strong_fields,
        }

    overall_score = round(total_weighted * 10, 1)  # Scale to 0-100

    label = "Unknown"
    advice = ""
    for (lo, hi), (lbl, adv) in SCORE_LABELS.items():
        if lo <= overall_score < hi:
            label = lbl
            advice = adv
            break

    # Compliance check
    compliance_result = None
    if target_compliance and target_compliance in COMPLIANCE_FRAMEWORKS:
        required_fields = COMPLIANCE_FRAMEWORKS[target_compliance]
        passed = []
        failed = []
        for field in required_fields:
            score = 0
            for dim_data in dimension_results.values():
                if field in dim_data["field_scores"]:
                    score = dim_data["field_scores"][field]
                    break
            if score >= 7:
                passed.append(field)
            else:
                failed.append({"field": field, "score": score, "required": 7})
        compliance_result = {
            "framework": target_compliance.upper(),
            "passed": len(passed),
            "total": len(required_fields),
            "pass_rate": round(len(passed) / len(required_fields) * 100, 1),
            "gaps": failed,
        }

    # Top risks
    risks = []
    for dim_name, dim_data in dimension_results.items():
        if dim_data["score"] < 5:
            risks.append({
                "dimension": dim_name,
                "score": dim_data["score"],
                "risk": f"Low {dim_name} score ({dim_data['score']}/10) may not meet enterprise requirements",
                "remediation": f"Address weak areas: {', '.join(dim_data['weak_fields'])}",
            })

    return {
        "name": name,
        "architecture_type": arch_type,
        "overall_score": overall_score,
        "label": label,
        "advice": advice,
        "dimensions": dimension_results,
        "compliance": compliance_result,
        "risks": risks,
        "weak_dimensions": [d for d, v in dimension_results.items() if v["score"] < 5],
        "strong_dimensions": [d for d, v in dimension_results.items() if v["score"] >= 8],
    }


def format_human(results, threshold):
    """Format results for human-readable output."""
    lines = []
    lines.append("=" * 70)
    lines.append("ARCHITECTURE SCORING REPORT")
    lines.append(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}")
    lines.append(f"Qualification Threshold: {threshold}/100")
    lines.append("=" * 70)

    for result in results:
        lines.append(f"\n  Architecture: {result['name']}")
        lines.append(f"  Type: {result['architecture_type']}")
        lines.append(f"  Overall Score: {result['overall_score']}/100 ({result['label']})")
        lines.append(f"  Assessment: {result['advice']}")
        status = "QUALIFIED" if result["overall_score"] >= threshold else "BELOW THRESHOLD"
        lines.append(f"  Status: {status}")

        lines.append(f"\n  Dimension Scores:")
        for dim_name, dim_data in result["dimensions"].items():
            bar_len = int(dim_data["score"])
            bar = "#" * bar_len + "." * (10 - bar_len)
            flag = " << WEAK" if dim_data["score"] < 5 else ""
            lines.append(
                f"    {dim_name:<16} [{bar}] {dim_data['score']:.1f}/10 "
                f"(wt: {dim_data['weight']:.0%}, contrib: {dim_data['weighted_contribution']:.2f}){flag}"
            )

            if dim_data["weak_fields"]:
                lines.append(f"      Gaps: {', '.join(dim_data['weak_fields'])}")

        if result["compliance"]:
            comp = result["compliance"]
            lines.append(f"\n  Compliance Check: {comp['framework']}")
            lines.append(f"    Passed: {comp['passed']}/{comp['total']} ({comp['pass_rate']}%)")
            if comp["gaps"]:
                lines.append(f"    Gaps:")
                for gap in comp["gaps"]:
                    lines.append(f"      {gap['field']}: {gap['score']}/10 (need 7+)")

        if result["risks"]:
            lines.append(f"\n  Risks:")
            for risk in result["risks"]:
                lines.append(f"    [{risk['dimension']}] {risk['risk']}")
                lines.append(f"      Fix: {risk['remediation']}")

        lines.append("-" * 70)

    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(
        description="Score proposed solution architectures against best practices."
    )
    parser.add_argument("--data", required=True, help="Path to architecture data CSV or JSON file")
    parser.add_argument(
        "--threshold", type=float, default=70, help="Minimum passing score (default: 70)"
    )
    parser.add_argument("--json", action="store_true", help="Output results as JSON")

    args = parser.parse_args()

    if not os.path.exists(args.data):
        print(f"Error: File not found: {args.data}", file=sys.stderr)
        sys.exit(1)

    architectures = load_data(args.data)
    if not architectures:
        print("Error: No architecture data found in input file.", file=sys.stderr)
        sys.exit(1)

    results = [score_architecture(a) for a in architectures]

    if args.json:
        print(json.dumps(results, indent=2))
    else:
        print(format_human(results, args.threshold))

    below = sum(1 for r in results if r["overall_score"] < args.threshold)
    sys.exit(1 if below > 0 else 0)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Score migration complexity for platform transitions.

Evaluates migration projects across seven weighted dimensions: application
portfolio, infrastructure type, database count, architecture style,
compliance requirements, downtime tolerance, and data volume.
Produces a complexity score with recommended migration strategy.

Usage:
    python migration_assessor.py --data migration.json
    python migration_assessor.py --data migration.csv --json
    python migration_assessor.py --data migration.json --detailed
"""

import argparse
import csv
import json
import os
import sys
from datetime import datetime


COMPLEXITY_DIMENSIONS = {
    "application_count": {
        "weight": 0.20,
        "ranges": [(1, 5, 10), (6, 15, 30), (16, 50, 60), (51, 200, 80), (201, 99999, 100)],
        "description": "Number of applications to migrate",
    },
    "infrastructure_type": {
        "weight": 0.15,
        "values": {
            "cloud": 10, "cloud_native": 5, "virtual": 30, "vm": 30,
            "containerized": 15, "bare_metal": 70, "mainframe": 90, "hybrid": 50,
        },
        "description": "Current infrastructure type complexity",
    },
    "database_count": {
        "weight": 0.15,
        "ranges": [(0, 2, 10), (3, 10, 30), (11, 30, 55), (31, 100, 80), (101, 99999, 100)],
        "description": "Number of databases requiring migration",
    },
    "architecture_style": {
        "weight": 0.15,
        "values": {
            "microservices": 15, "serverless": 10, "soa": 40, "service_oriented": 40,
            "monolith": 70, "monolithic": 70, "legacy": 85, "mainframe": 95,
            "distributed": 30, "event_driven": 25,
        },
        "description": "Architectural style complexity for decoupling",
    },
    "compliance_requirements": {
        "weight": 0.10,
        "values": {
            "none": 5, "basic": 15, "soc2": 35, "hipaa": 55, "pci": 50, "pci_dss": 50,
            "gdpr": 40, "fedramp": 75, "financial": 60, "healthcare": 65,
            "government": 70, "multi_framework": 85,
        },
        "description": "Compliance framework complexity during migration",
    },
    "downtime_tolerance": {
        "weight": 0.10,
        "values": {
            "high": 10, "flexible": 15, "moderate": 35, "standard": 35,
            "low": 65, "minimal": 75, "zero": 95, "none": 95,
        },
        "description": "Tolerance for downtime during migration",
    },
    "data_volume_gb": {
        "weight": 0.15,
        "ranges": [(0, 100, 10), (101, 1000, 25), (1001, 10000, 50), (10001, 100000, 75), (100001, 99999999, 95)],
        "description": "Total data volume to migrate",
    },
}

COMPLEXITY_TIERS = {
    (0, 25): {
        "tier": "Low",
        "strategy": "Lift and Shift",
        "description": "Simple migration. Direct rehosting with minimal changes.",
        "estimated_weeks": "4-8",
        "risk_level": "Low",
    },
    (25, 45): {
        "tier": "Moderate",
        "strategy": "Replatform",
        "description": "Moderate complexity. Replatform with containerization and minor refactoring.",
        "estimated_weeks": "8-16",
        "risk_level": "Medium",
    },
    (45, 65): {
        "tier": "High",
        "strategy": "Refactor / Rearchitect",
        "description": "High complexity. Phased migration with significant refactoring required.",
        "estimated_weeks": "16-32",
        "risk_level": "High",
    },
    (65, 85): {
        "tier": "Very High",
        "strategy": "Strangler Fig Pattern",
        "description": "Very high complexity. Incremental migration using strangler fig with parallel-run.",
        "estimated_weeks": "32-52",
        "risk_level": "Very High",
    },
    (85, 101): {
        "tier": "Extreme",
        "strategy": "Full Rearchitecture",
        "description": "Extreme complexity. Multi-phase rearchitecture program. Consider phased approach over 12+ months.",
        "estimated_weeks": "52+",
        "risk_level": "Critical",
    },
}


def load_data(filepath):
    """Load migration assessment data from CSV or JSON file."""
    ext = os.path.splitext(filepath)[1].lower()
    if ext == ".json":
        with open(filepath, "r") as f:
            data = json.load(f)
            return data if isinstance(data, list) else [data]
    elif ext == ".csv":
        with open(filepath, "r") as f:
            return list(csv.DictReader(f))
    else:
        print(f"Error: Unsupported file format '{ext}'. Use .csv or .json.", file=sys.stderr)
        sys.exit(1)


def safe_float(value, default=0.0):
    """Parse float safely."""
    try:
        return float(str(value).replace(",", "").strip())
    except (ValueError, TypeError):
        return default


def safe_int(value, default=0):
    """Parse int safely."""
    try:
        return int(float(str(value).strip()))
    except (ValueError, TypeError):
        return default


def score_range_dimension(value, ranges):
    """Score a numeric dimension against defined ranges."""
    num = safe_int(value, 0) if isinstance(value, str) else int(value) if value else 0
    for lo, hi, score in ranges:
        if lo <= num <= hi:
            return score
    return ranges[-1][2] if ranges else 50


def score_value_dimension(value, values_map):
    """Score a categorical dimension against defined values."""
    if not value:
        return 50  # Default moderate complexity
    val = str(value).lower().strip().replace(" ", "_").replace("-", "_")
    for key, score in values_map.items():
        if key in val:
            return score
    return 50  # Default if not recognized


def assess_migration(project):
    """Assess migration complexity for a single project."""
    name = project.get("name", project.get("project", project.get("customer", "Unknown")))
    source = project.get("source_platform", project.get("from", "Unknown"))
    target = project.get("target_platform", project.get("to", "Cloud"))

    dimension_scores = {}
    total_weighted = 0

    for dim_name, dim_config in COMPLEXITY_DIMENSIONS.items():
        raw_value = project.get(dim_name, project.get(dim_name.replace("_", " "), ""))

        if "ranges" in dim_config:
            score = score_range_dimension(raw_value, dim_config["ranges"])
        else:
            score = score_value_dimension(raw_value, dim_config["values"])

        weighted = score * dim_config["weight"]
        total_weighted += weighted

        dimension_scores[dim_name] = {
            "raw_value": str(raw_value) if raw_value else "Not specified",
            "complexity_score": score,
            "weight": dim_config["weight"],
            "weighted_score": round(weighted, 2),
            "description": dim_config["description"],
        }

    overall_score = round(total_weighted, 1)

    # Determine tier and strategy
    tier_info = None
    for (lo, hi), info in COMPLEXITY_TIERS.items():
        if lo <= overall_score < hi:
            tier_info = info
            break
    if not tier_info:
        tier_info = list(COMPLEXITY_TIERS.values())[-1]

    # Risk factors
    risks = []
    high_dims = [(d, v) for d, v in dimension_scores.items() if v["complexity_score"] >= 70]
    for dim, data in high_dims:
        risks.append({
            "dimension": dim.replace("_", " ").title(),
            "score": data["complexity_score"],
            "description": data["description"],
            "mitigation": _get_mitigation(dim),
        })

    # Resource estimation
    team_size = _estimate_team_size(overall_score)

    # Migration phases
    phases = _generate_phases(overall_score, tier_info["strategy"])

    return {
        "name": name,
        "source_platform": source,
        "target_platform": target,
        "complexity_score": overall_score,
        "complexity_tier": tier_info["tier"],
        "recommended_strategy": tier_info["strategy"],
        "strategy_description": tier_info["description"],
        "estimated_duration_weeks": tier_info["estimated_weeks"],
        "risk_level": tier_info["risk_level"],
        "dimension_scores": dimension_scores,
        "top_risks": risks,
        "estimated_team_size": team_size,
        "migration_phases": phases,
    }


def _get_mitigation(dimension):
    """Get mitigation strategy for a high-complexity dimension."""
    mitigations = {
        "application_count": "Prioritize applications by business impact. Migrate in waves of 5-10.",
        "infrastructure_type": "Assess each system individually. Consider interim virtualization layer.",
        "database_count": "Map data dependencies first. Migrate databases in dependency order.",
        "architecture_style": "Use strangler fig pattern. Decouple incrementally rather than big-bang.",
        "compliance_requirements": "Engage compliance team early. Run parallel compliance validation.",
        "downtime_tolerance": "Plan blue-green deployment. Test failback procedures before cutover.",
        "data_volume_gb": "Use incremental data sync. Pre-stage data before cutover window.",
    }
    return mitigations.get(dimension, "Assess specific requirements and plan mitigation.")


def _estimate_team_size(score):
    """Estimate team size based on complexity."""
    if score < 25:
        return {"engineers": 2, "architects": 1, "pm": 1, "total": 4}
    elif score < 45:
        return {"engineers": 4, "architects": 1, "pm": 1, "total": 6}
    elif score < 65:
        return {"engineers": 6, "architects": 2, "pm": 1, "total": 9}
    elif score < 85:
        return {"engineers": 10, "architects": 2, "pm": 2, "total": 14}
    else:
        return {"engineers": 15, "architects": 3, "pm": 2, "total": 20}


def _generate_phases(score, strategy):
    """Generate recommended migration phases."""
    if score < 25:
        return [
            {"phase": "1. Assessment & Planning", "duration": "1-2 weeks"},
            {"phase": "2. Environment Setup", "duration": "1 week"},
            {"phase": "3. Migration Execution", "duration": "1-2 weeks"},
            {"phase": "4. Testing & Validation", "duration": "1 week"},
            {"phase": "5. Cutover & Go-Live", "duration": "1 day"},
        ]
    elif score < 45:
        return [
            {"phase": "1. Discovery & Assessment", "duration": "2 weeks"},
            {"phase": "2. Architecture & Planning", "duration": "2 weeks"},
            {"phase": "3. Environment Build", "duration": "2 weeks"},
            {"phase": "4. Migration Wave 1 (Pilot)", "duration": "2 weeks"},
            {"phase": "5. Migration Wave 2+", "duration": "4 weeks"},
            {"phase": "6. Testing & Optimization", "duration": "2 weeks"},
            {"phase": "7. Cutover & Decommission", "duration": "1 week"},
        ]
    elif score < 65:
        return [
            {"phase": "1. Detailed Discovery", "duration": "3 weeks"},
            {"phase": "2. Architecture Design", "duration": "3 weeks"},
            {"phase": "3. Proof of Concept", "duration": "2 weeks"},
            {"phase": "4. Environment Build & Security", "duration": "3 weeks"},
            {"phase": "5. Wave 1: Foundation", "duration": "4 weeks"},
            {"phase": "6. Wave 2: Core Systems", "duration": "6 weeks"},
            {"phase": "7. Wave 3: Remaining Systems", "duration": "4 weeks"},
            {"phase": "8. Integration Testing", "duration": "3 weeks"},
            {"phase": "9. Performance Tuning", "duration": "2 weeks"},
            {"phase": "10. Cutover & Hypercare", "duration": "2 weeks"},
        ]
    else:
        return [
            {"phase": "1. Enterprise Assessment", "duration": "4 weeks"},
            {"phase": "2. Target Architecture", "duration": "4 weeks"},
            {"phase": "3. Proof of Concept", "duration": "4 weeks"},
            {"phase": "4. Foundation Build", "duration": "6 weeks"},
            {"phase": "5. Wave 1: Low-Risk Systems", "duration": "6 weeks"},
            {"phase": "6. Wave 2: Core Platform", "duration": "8 weeks"},
            {"phase": "7. Wave 3: Complex Systems", "duration": "8 weeks"},
            {"phase": "8. Wave 4: Legacy Decouple", "duration": "8 weeks"},
            {"phase": "9. Integration & Security", "duration": "4 weeks"},
            {"phase": "10. Performance & Chaos Testing", "duration": "3 weeks"},
            {"phase": "11. Staged Cutover", "duration": "4 weeks"},
            {"phase": "12. Decommission & Hypercare", "duration": "4 weeks"},
        ]


def format_human(results):
    """Format results for human-readable output."""
    lines = []
    lines.append("=" * 70)
    lines.append("MIGRATION COMPLEXITY ASSESSMENT")
    lines.append(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}")
    lines.append("=" * 70)

    for r in results:
        lines.append(f"\n  Project: {r['name']}")
        lines.append(f"  Migration: {r['source_platform']} -> {r['target_platform']}")
        lines.append(f"  Complexity Score: {r['complexity_score']}/100 ({r['complexity_tier']})")
        lines.append(f"  Risk Level: {r['risk_level']}")
        lines.append(f"  Recommended Strategy: {r['recommended_strategy']}")
        lines.append(f"  Description: {r['strategy_description']}")
        lines.append(f"  Estimated Duration: {r['estimated_duration_weeks']} weeks")

        team = r["estimated_team_size"]
        lines.append(f"  Estimated Team: {team['total']} people "
                     f"({team['engineers']} eng, {team['architects']} arch, {team['pm']} PM)")

        lines.append(f"\n  Complexity Dimensions:")
        for dim_name, dim_data in r["dimension_scores"].items():
            score = dim_data["complexity_score"]
            bar_len = int(score / 10)
            bar = "#" * bar_len + "." * (10 - bar_len)
            flag = " << HIGH" if score >= 70 else ""
            lines.append(
                f"    {dim_name.replace('_', ' '):<24} [{bar}] {score:>3}/100 "
                f"(wt: {dim_data['weight']:.0%}) = {dim_data['weighted_score']:.1f}{flag}"
            )
            lines.append(f"      Value: {dim_data['raw_value']}")

        if r["top_risks"]:
            lines.append(f"\n  Top Risks:")
            for risk in r["top_risks"]:
                lines.append(f"    [{risk['score']}] {risk['dimension']}: {risk['description']}")
                lines.append(f"         Mitigation: {risk['mitigation']}")

        lines.append(f"\n  Migration Phases:")
        for phase in r["migration_phases"]:
            lines.append(f"    {phase['phase']:<45} {phase['duration']}")

        lines.append("-" * 70)

    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(
        description="Score migration complexity and recommend migration strategy."
    )
    parser.add_argument("--data", required=True, help="Path to migration data CSV or JSON file")
    parser.add_argument("--json", action="store_true", help="Output results as JSON")
    parser.add_argument(
        "--detailed", action="store_true", help="Include detailed phase breakdown (default in text mode)"
    )

    args = parser.parse_args()

    if not os.path.exists(args.data):
        print(f"Error: File not found: {args.data}", file=sys.stderr)
        sys.exit(1)

    projects = load_data(args.data)
    if not projects:
        print("Error: No migration data found in input file.", file=sys.stderr)
        sys.exit(1)

    results = [assess_migration(p) for p in projects]

    if args.json:
        print(json.dumps(results, indent=2))
    else:
        print(format_human(results))

    high_risk = sum(1 for r in results if r["complexity_score"] >= 65)
    sys.exit(1 if high_risk > 0 else 0)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Estimate infrastructure sizing based on workload requirements.

Calculates compute, storage, and network requirements from user counts,
data volumes, and performance targets. Produces sizing recommendations
with cost tier estimates.

Usage:
    python sizing_calculator.py --data workload.json
    python sizing_calculator.py --data workload.csv --json
    python sizing_calculator.py --data workload.json --growth-factor 2.0
"""

import argparse
import csv
import json
import math
import os
import sys
from datetime import datetime


# Sizing reference tables (cloud-agnostic tiers)
COMPUTE_TIERS = [
    {"name": "Small", "vcpus": 2, "ram_gb": 4, "max_concurrent": 500, "monthly_cost": 70},
    {"name": "Medium", "vcpus": 4, "ram_gb": 16, "max_concurrent": 2000, "monthly_cost": 200},
    {"name": "Large", "vcpus": 8, "ram_gb": 32, "max_concurrent": 5000, "monthly_cost": 400},
    {"name": "XLarge", "vcpus": 16, "ram_gb": 64, "max_concurrent": 10000, "monthly_cost": 800},
    {"name": "2XLarge", "vcpus": 32, "ram_gb": 128, "max_concurrent": 25000, "monthly_cost": 1600},
    {"name": "4XLarge", "vcpus": 64, "ram_gb": 256, "max_concurrent": 50000, "monthly_cost": 3200},
]

STORAGE_TIERS = [
    {"name": "Standard SSD", "iops": 3000, "throughput_mbps": 125, "cost_per_gb": 0.10},
    {"name": "Performance SSD", "iops": 16000, "throughput_mbps": 250, "cost_per_gb": 0.17},
    {"name": "Premium SSD", "iops": 64000, "throughput_mbps": 900, "cost_per_gb": 0.30},
]

DB_TIERS = [
    {"name": "Small DB", "vcpus": 2, "ram_gb": 8, "max_connections": 100, "storage_gb": 100, "monthly_cost": 150},
    {"name": "Medium DB", "vcpus": 4, "ram_gb": 16, "max_connections": 500, "storage_gb": 500, "monthly_cost": 400},
    {"name": "Large DB", "vcpus": 8, "ram_gb": 32, "max_connections": 1000, "storage_gb": 1000, "monthly_cost": 800},
    {"name": "XLarge DB", "vcpus": 16, "ram_gb": 64, "max_connections": 2000, "storage_gb": 2000, "monthly_cost": 1600},
    {"name": "2XLarge DB", "vcpus": 32, "ram_gb": 128, "max_connections": 5000, "storage_gb": 5000, "monthly_cost": 3200},
]


def load_data(filepath):
    """Load workload data from CSV or JSON file."""
    ext = os.path.splitext(filepath)[1].lower()
    if ext == ".json":
        with open(filepath, "r") as f:
            data = json.load(f)
            return data if isinstance(data, list) else [data]
    elif ext == ".csv":
        with open(filepath, "r") as f:
            return list(csv.DictReader(f))
    else:
        print(f"Error: Unsupported file format '{ext}'. Use .csv or .json.", file=sys.stderr)
        sys.exit(1)


def safe_float(value, default=0.0):
    """Parse float safely."""
    try:
        return float(str(value).replace(",", "").strip())
    except (ValueError, TypeError):
        return default


def safe_int(value, default=0):
    """Parse int safely."""
    try:
        return int(float(str(value).strip()))
    except (ValueError, TypeError):
        return default


def select_compute_tier(concurrent_users, growth_factor):
    """Select appropriate compute tier based on concurrent users."""
    target = concurrent_users * growth_factor
    for tier in COMPUTE_TIERS:
        if target <= tier["max_concurrent"]:
            return tier
    return COMPUTE_TIERS[-1]  # Largest tier


def calculate_compute_instances(concurrent_users, growth_factor, ha_enabled):
    """Calculate number of compute instances needed."""
    tier = select_compute_tier(concurrent_users, growth_factor)
    target_users = concurrent_users * growth_factor

    instances = max(1, math.ceil(target_users / tier["max_concurrent"]))
    if ha_enabled:
        instances = max(instances, 2)  # Minimum 2 for HA
        instances += 1  # Additional instance for failover

    return {
        "tier": tier["name"],
        "vcpus_per_instance": tier["vcpus"],
        "ram_gb_per_instance": tier["ram_gb"],
        "instances": instances,
        "total_vcpus": tier["vcpus"] * instances,
        "total_ram_gb": tier["ram_gb"] * instances,
        "monthly_cost": tier["monthly_cost"] * instances,
        "max_capacity": tier["max_concurrent"] * instances,
    }


def calculate_storage(data_volume_gb, growth_factor, retention_months):
    """Calculate storage requirements."""
    base_storage = data_volume_gb * growth_factor
    projected_growth = base_storage * (1 + (retention_months * 0.05))  # 5% monthly growth assumption
    total_storage = math.ceil(projected_growth)

    # Select storage tier
    tier = STORAGE_TIERS[0]  # Default to standard
    if total_storage > 1000:
        tier = STORAGE_TIERS[1]  # Performance for larger volumes
    if total_storage > 5000:
        tier = STORAGE_TIERS[2]  # Premium for very large volumes

    # Backup storage (1.5x primary)
    backup_storage = math.ceil(total_storage * 1.5)

    return {
        "primary_storage_gb": total_storage,
        "backup_storage_gb": backup_storage,
        "total_storage_gb": total_storage + backup_storage,
        "storage_tier": tier["name"],
        "iops": tier["iops"],
        "throughput_mbps": tier["throughput_mbps"],
        "monthly_cost": round(total_storage * tier["cost_per_gb"], 2),
        "backup_monthly_cost": round(backup_storage * tier["cost_per_gb"] * 0.5, 2),  # Backup at 50% rate
    }


def calculate_database(total_users, concurrent_users, data_volume_gb, growth_factor, ha_enabled):
    """Calculate database sizing."""
    target_connections = max(concurrent_users * growth_factor * 0.1, 50)  # ~10% of concurrent need DB connections
    target_storage = data_volume_gb * growth_factor * 1.5  # 1.5x for indexes and overhead

    selected_tier = DB_TIERS[0]
    for tier in DB_TIERS:
        if target_connections <= tier["max_connections"] and target_storage <= tier["storage_gb"]:
            selected_tier = tier
            break
    else:
        selected_tier = DB_TIERS[-1]

    replicas = 0
    if ha_enabled:
        replicas = 1  # Read replica for HA
    if concurrent_users > 5000:
        replicas += 1  # Additional read replica for scale

    return {
        "tier": selected_tier["name"],
        "vcpus": selected_tier["vcpus"],
        "ram_gb": selected_tier["ram_gb"],
        "max_connections": selected_tier["max_connections"],
        "allocated_storage_gb": selected_tier["storage_gb"],
        "read_replicas": replicas,
        "monthly_cost": selected_tier["monthly_cost"] * (1 + replicas),
    }


def calculate_network(concurrent_users, data_volume_gb):
    """Calculate network requirements."""
    estimated_bandwidth_mbps = max(concurrent_users * 0.1, 10)  # ~100kbps per concurrent user
    cdn_recommended = concurrent_users > 1000

    return {
        "estimated_bandwidth_mbps": round(estimated_bandwidth_mbps, 1),
        "cdn_recommended": cdn_recommended,
        "load_balancer": concurrent_users > 500,
        "waf_recommended": True,
        "monthly_cost": round(estimated_bandwidth_mbps * 5, 2),  # Rough estimate
    }


def size_infrastructure(workload, growth_factor):
    """Calculate full infrastructure sizing for a workload."""
    name = workload.get("name", workload.get("project", workload.get("customer", "Unknown")))
    total_users = safe_int(workload.get("total_users", workload.get("users", 0)))
    concurrent_users = safe_int(workload.get("concurrent_users", workload.get("peak_users", 0)))
    if concurrent_users == 0 and total_users > 0:
        concurrent_users = max(int(total_users * 0.1), 10)  # Default 10% concurrency

    data_volume_gb = safe_float(workload.get("data_volume_gb", workload.get("data_gb", 0)))
    retention_months = safe_int(workload.get("retention_months", 12))
    ha_required = str(workload.get("ha_required", workload.get("high_availability", "true"))).lower() in ("true", "1", "yes")

    response_time_target = workload.get("response_time_ms", workload.get("latency_target", "500ms"))
    uptime_target = workload.get("uptime_target", workload.get("sla", "99.9%"))
    region = workload.get("region", workload.get("deployment_region", "Single Region"))
    environments = safe_int(workload.get("environments", 3))  # dev, staging, prod

    compute = calculate_compute_instances(concurrent_users, growth_factor, ha_required)
    storage = calculate_storage(data_volume_gb, growth_factor, retention_months)
    database = calculate_database(total_users, concurrent_users, data_volume_gb, growth_factor, ha_required)
    network = calculate_network(concurrent_users, data_volume_gb)

    # Total cost estimate
    prod_monthly = compute["monthly_cost"] + storage["monthly_cost"] + storage["backup_monthly_cost"] + database["monthly_cost"] + network["monthly_cost"]
    # Non-prod environments at 50% of prod cost
    non_prod_monthly = prod_monthly * 0.5 * max(environments - 1, 0)
    total_monthly = round(prod_monthly + non_prod_monthly, 2)
    total_annual = round(total_monthly * 12, 2)

    # Sizing confidence
    if total_users > 0 and concurrent_users > 0 and data_volume_gb > 0:
        confidence = "High"
        confidence_note = "All key inputs provided. Estimates are reliable."
    elif total_users > 0 or concurrent_users > 0:
        confidence = "Medium"
        confidence_note = "Partial inputs. Some values estimated from defaults."
    else:
        confidence = "Low"
        confidence_note = "Minimal inputs. Treat as rough order-of-magnitude estimate."

    return {
        "name": name,
        "inputs": {
            "total_users": total_users,
            "concurrent_users": concurrent_users,
            "data_volume_gb": data_volume_gb,
            "retention_months": retention_months,
            "ha_required": ha_required,
            "growth_factor": growth_factor,
            "response_time_target": str(response_time_target),
            "uptime_target": str(uptime_target),
            "region": region,
            "environments": environments,
        },
        "compute": compute,
        "storage": storage,
        "database": database,
        "network": network,
        "cost_estimate": {
            "production_monthly": round(prod_monthly, 2),
            "non_production_monthly": round(non_prod_monthly, 2),
            "total_monthly": total_monthly,
            "total_annual": total_annual,
        },
        "confidence": confidence,
        "confidence_note": confidence_note,
    }


def format_human(results):
    """Format results for human-readable output."""
    lines = []
    lines.append("=" * 70)
    lines.append("INFRASTRUCTURE SIZING REPORT")
    lines.append(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}")
    lines.append("=" * 70)

    for r in results:
        lines.append(f"\n  Project: {r['name']}")
        lines.append(f"  Confidence: {r['confidence']} - {r['confidence_note']}")

        inp = r["inputs"]
        lines.append(f"\n  INPUTS")
        lines.append(f"    Users: {inp['total_users']:,} total / {inp['concurrent_users']:,} concurrent")
        lines.append(f"    Data: {inp['data_volume_gb']:,.1f} GB  |  Retention: {inp['retention_months']} months")
        lines.append(f"    HA: {'Yes' if inp['ha_required'] else 'No'}  |  Growth Factor: {inp['growth_factor']}x")
        lines.append(f"    Targets: {inp['response_time_target']} response, {inp['uptime_target']} uptime")
        lines.append(f"    Environments: {inp['environments']}  |  Region: {inp['region']}")

        c = r["compute"]
        lines.append(f"\n  COMPUTE")
        lines.append(f"    Tier: {c['tier']}  |  Instances: {c['instances']}")
        lines.append(f"    Total vCPUs: {c['total_vcpus']}  |  Total RAM: {c['total_ram_gb']} GB")
        lines.append(f"    Max Capacity: {c['max_capacity']:,} concurrent users")
        lines.append(f"    Monthly Cost: ${c['monthly_cost']:,.2f}")

        s = r["storage"]
        lines.append(f"\n  STORAGE")
        lines.append(f"    Primary: {s['primary_storage_gb']:,} GB ({s['storage_tier']})")
        lines.append(f"    Backup: {s['backup_storage_gb']:,} GB")
        lines.append(f"    IOPS: {s['iops']:,}  |  Throughput: {s['throughput_mbps']} MB/s")
        lines.append(f"    Monthly Cost: ${s['monthly_cost'] + s['backup_monthly_cost']:,.2f}")

        d = r["database"]
        lines.append(f"\n  DATABASE")
        lines.append(f"    Tier: {d['tier']}  |  vCPUs: {d['vcpus']}  |  RAM: {d['ram_gb']} GB")
        lines.append(f"    Max Connections: {d['max_connections']:,}  |  Storage: {d['allocated_storage_gb']:,} GB")
        lines.append(f"    Read Replicas: {d['read_replicas']}")
        lines.append(f"    Monthly Cost: ${d['monthly_cost']:,.2f}")

        n = r["network"]
        lines.append(f"\n  NETWORK")
        lines.append(f"    Bandwidth: {n['estimated_bandwidth_mbps']:.1f} Mbps")
        lines.append(f"    CDN: {'Recommended' if n['cdn_recommended'] else 'Optional'}")
        lines.append(f"    Load Balancer: {'Required' if n['load_balancer'] else 'Optional'}")
        lines.append(f"    WAF: {'Recommended' if n['waf_recommended'] else 'Optional'}")
        lines.append(f"    Monthly Cost: ${n['monthly_cost']:,.2f}")

        cost = r["cost_estimate"]
        lines.append(f"\n  COST SUMMARY")
        lines.append(f"    Production Monthly:      ${cost['production_monthly']:>10,.2f}")
        lines.append(f"    Non-Production Monthly:  ${cost['non_production_monthly']:>10,.2f}")
        lines.append(f"    Total Monthly:           ${cost['total_monthly']:>10,.2f}")
        lines.append(f"    Total Annual:            ${cost['total_annual']:>10,.2f}")

        lines.append("-" * 70)

    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(
        description="Estimate infrastructure sizing from workload requirements."
    )
    parser.add_argument("--data", required=True, help="Path to workload data CSV or JSON file")
    parser.add_argument(
        "--growth-factor",
        type=float,
        default=1.5,
        help="Growth multiplier for capacity planning (default: 1.5)",
    )
    parser.add_argument("--json", action="store_true", help="Output results as JSON")

    args = parser.parse_args()

    if not os.path.exists(args.data):
        print(f"Error: File not found: {args.data}", file=sys.stderr)
        sys.exit(1)

    workloads = load_data(args.data)
    if not workloads:
        print("Error: No workload data found in input file.", file=sys.stderr)
        sys.exit(1)

    results = [size_infrastructure(w, args.growth_factor) for w in workloads]

    if args.json:
        print(json.dumps(results, indent=2))
    else:
        print(format_human(results))

    sys.exit(0)


if __name__ == "__main__":
    main()