// Cyber Risk Scoring Engine
type RiskScore struct {
    Overall          float64            `json:"overall_score"`
    Categories       map[string]float64 `json:"category_scores"`
    Vulnerabilities  int                `json:"vulnerability_count"`
    RiskLevel        string             `json:"risk_level"`
    Insurable        bool               `json:"insurable"`
    Recommendations  []string           `json:"recommendations"`
}

type RiskInput struct {
    BusinessProfile  BusinessProfile    `json:"business_profile"`
    VulnerabilityScan VulnerabilityData `json:"vulnerability_scan"`
    Questionnaire    []QuestionAnswer   `json:"questionnaire"`
}

func (s *ScoringService) CalculateRiskScore(ctx context.Context, input RiskInput) (*RiskScore, error) {
    // 1. Score each category independently
    categories := map[string]float64{
        "network_security":   s.scoreNetworkSecurity(input.VulnerabilityScan),
        "data_protection":    s.scoreDataProtection(input.Questionnaire),
        "access_control":     s.scoreAccessControl(input.Questionnaire),
        "incident_response":  s.scoreIncidentResponse(input.Questionnaire),
        "business_continuity": s.scoreBusinessContinuity(input.Questionnaire),
        "compliance":         s.scoreCompliance(input.BusinessProfile),
    }

    // 2. Weighted average — network security and data protection weighted higher
    weights := map[string]float64{
        "network_security":   0.25,
        "data_protection":    0.25,
        "access_control":     0.15,
        "incident_response":  0.15,
        "business_continuity": 0.10,
        "compliance":         0.10,
    }

    var overallScore float64
    for category, score := range categories {
        overallScore += score * weights[category]
    }

    // 3. Determine risk level and insurability
    riskLevel, insurable := classifyRisk(overallScore)

    return &RiskScore{
        Overall:         overallScore,
        Categories:      categories,
        Vulnerabilities: input.VulnerabilityScan.TotalFindings,
        RiskLevel:       riskLevel,
        Insurable:       insurable,
        Recommendations: generateRecommendations(categories),
    }, nil
}

func classifyRisk(score float64) (string, bool) {
    switch {
    case score >= 80:
        return "LOW", true
    case score >= 50:
        return "MEDIUM", true
    case score >= 30:
        return "HIGH", true
    default:
        return "CRITICAL", false // Remediation required before insurable
    }
}

// D3.js Radar Chart for Risk Category Visualization
interface RiskCategory {
  category: string;
  score: number;
  maxScore: number;
  label: string;
}

function renderRadarChart(
  container: string,
  data: RiskCategory[],
  options: ChartOptions,
): void {
  const svg = d3
    .select(container)
    .append("svg")
    .attr("width", options.width)
    .attr("height", options.height);

  const radius = Math.min(options.width, options.height) / 2 - options.margin;
  const angleSlice = (Math.PI * 2) / data.length;

  // Draw concentric circles (score levels)
  const levels = [20, 40, 60, 80, 100];
  levels.forEach((level) => {
    svg
      .append("circle")
      .attr("r", (radius * level) / 100)
      .attr("class", `level-${level}`)
      .style("fill", "none")
      .style("stroke", getRiskColor(level));
  });

  // Draw radar area
  const radarLine = d3
    .lineRadial<RiskCategory>()
    .radius((d) => (radius * d.score) / 100)
    .angle((_, i) => i * angleSlice)
    .curve(d3.curveLinearClosed);

  svg
    .append("path")
    .datum(data)
    .attr("d", radarLine)
    .style("fill", getOverallColor(data))
    .style("fill-opacity", 0.3)
    .style("stroke", getOverallColor(data))
    .style("stroke-width", 2);

  // Interactive tooltips on hover
  data.forEach((d, i) => {
    const x = radius * (d.score / 100) * Math.cos(angleSlice * i - Math.PI / 2);
    const y = radius * (d.score / 100) * Math.sin(angleSlice * i - Math.PI / 2);

    svg
      .append("circle")
      .attr("cx", x)
      .attr("cy", y)
      .attr("r", 6)
      .on("mouseover", () => showTooltip(d))
      .on("mouseout", hideTooltip);
  });
}

// Adaptive Questionnaire Engine
interface Question {
  id: string;
  text: string;
  type: "select" | "text" | "number" | "boolean";
  options?: string[];
  dependencies?: {
    questionId: string;
    condition: "equals" | "gt" | "lt" | "includes";
    value: any;
    action: "show" | "skip";
  }[];
  weight: number; // Impact on risk score
}

function getNextQuestions(
  allQuestions: Question[],
  answers: Record<string, any>,
): Question[] {
  return allQuestions.filter((q) => {
    if (!q.dependencies) return true;

    return q.dependencies.every((dep) => {
      const answer = answers[dep.questionId];
      if (answer === undefined) return dep.action === "skip";

      switch (dep.condition) {
        case "equals":
          return dep.action === "show"
            ? answer === dep.value
            : answer !== dep.value;
        case "gt":
          return dep.action === "show"
            ? answer > dep.value
            : answer <= dep.value;
        case "includes":
          return dep.action === "show"
            ? dep.value.includes(answer)
            : !dep.value.includes(answer);
        default:
          return true;
      }
    });
  });
}