class AnalysisSessionSummary {
  const AnalysisSessionSummary({
    required this.sessionId,
    required this.observationId,
    required this.status,
    required this.message,
  });

  final String sessionId;
  final String observationId;
  final String status;
  final String message;

  factory AnalysisSessionSummary.fromJson(Map<String, dynamic> json) {
    return AnalysisSessionSummary(
      sessionId: json['session_id'] as String,
      observationId: json['observation_id'] as String,
      status: json['status'] as String,
      message: json['message'] as String,
    );
  }
}

class ObservationSummary {
  const ObservationSummary({
    required this.id,
    required this.modality,
    required this.durationMs,
    required this.sampleRate,
    required this.channels,
    required this.tags,
    required this.captureMetadata,
  });

  final String id;
  final String modality;
  final int durationMs;
  final int sampleRate;
  final int channels;
  final List<String> tags;
  final Map<String, dynamic> captureMetadata;

  factory ObservationSummary.fromJson(Map<String, dynamic> json) {
    return ObservationSummary(
      id: json['id'] as String,
      modality: json['modality'] as String,
      durationMs: json['duration_ms'] as int,
      sampleRate: json['sample_rate'] as int,
      channels: json['channels'] as int,
      tags: (json['tags'] as List<dynamic>).cast<String>(),
      captureMetadata:
          (json['capture_metadata'] as Map<String, dynamic>? ?? const {}),
    );
  }
}

class EvidenceSummary {
  const EvidenceSummary({
    required this.id,
    required this.producerModuleId,
    required this.category,
    required this.values,
    required this.confidence,
  });

  final String id;
  final String? producerModuleId;
  final String category;
  final Map<String, dynamic> values;
  final double confidence;

  factory EvidenceSummary.fromJson(Map<String, dynamic> json) {
    return EvidenceSummary(
      id: json['id'] as String,
      producerModuleId: json['producer_module_id'] as String?,
      category: json['category'] as String,
      values: (json['values'] as Map<String, dynamic>? ?? const {}),
      confidence: (json['confidence'] as num).toDouble(),
    );
  }
}

class ScoreCard {
  const ScoreCard({
    required this.total,
    required this.components,
    required this.penalties,
    required this.notes,
  });

  final double total;
  final Map<String, double> components;
  final Map<String, double> penalties;
  final List<String> notes;

  factory ScoreCard.fromJson(Map<String, dynamic> json) {
    Map<String, double> toDoubleMap(Map<String, dynamic>? source) {
      if (source == null) return const {};
      return source.map(
        (key, value) => MapEntry(key, (value as num).toDouble()),
      );
    }

    return ScoreCard(
      total: (json['total'] as num).toDouble(),
      components: toDoubleMap(json['components'] as Map<String, dynamic>?),
      penalties: toDoubleMap(json['penalties'] as Map<String, dynamic>?),
      notes: (json['notes'] as List<dynamic>? ?? const []).cast<String>(),
    );
  }
}

class ExperimentSummary {
  const ExperimentSummary({
    required this.id,
    required this.parentId,
    required this.hypothesisId,
    required this.title,
    required this.status,
    required this.pipelineSummary,
    required this.score,
    required this.failureReasons,
  });

  final String id;
  final String? parentId;
  final String? hypothesisId;
  final String title;
  final String status;
  final List<String> pipelineSummary;
  final ScoreCard score;
  final List<String> failureReasons;

  factory ExperimentSummary.fromJson(Map<String, dynamic> json) {
    return ExperimentSummary(
      id: json['id'] as String,
      parentId: json['parent_id'] as String?,
      hypothesisId: json['hypothesis_id'] as String?,
      title: json['title'] as String,
      status: json['status'] as String,
      pipelineSummary: (json['pipeline_summary'] as List<dynamic>)
          .cast<String>(),
      score: ScoreCard.fromJson(json['score'] as Map<String, dynamic>),
      failureReasons: (json['failure_reasons'] as List<dynamic>? ?? const [])
          .cast<String>(),
    );
  }
}

class HypothesisSummary {
  const HypothesisSummary({
    required this.id,
    required this.label,
    required this.rationale,
    required this.confidence,
    required this.relatedSignalProfiles,
  });

  final String id;
  final String label;
  final String rationale;
  final double confidence;
  final List<String> relatedSignalProfiles;

  factory HypothesisSummary.fromJson(Map<String, dynamic> json) {
    return HypothesisSummary(
      id: json['id'] as String,
      label: json['label'] as String,
      rationale: json['rationale'] as String,
      confidence: (json['confidence'] as num).toDouble(),
      relatedSignalProfiles: (json['related_signal_profiles'] as List<dynamic>)
          .cast<String>(),
    );
  }
}

class RankedFinding {
  const RankedFinding({
    required this.label,
    required this.confidence,
    required this.supportingEvidence,
    required this.contradictingEvidence,
  });

  final String label;
  final double confidence;
  final List<String> supportingEvidence;
  final List<String> contradictingEvidence;

  factory RankedFinding.fromJson(Map<String, dynamic> json) {
    return RankedFinding(
      label: json['label'] as String,
      confidence: (json['confidence'] as num).toDouble(),
      supportingEvidence: (json['supporting_evidence'] as List<dynamic>)
          .cast<String>(),
      contradictingEvidence: (json['contradicting_evidence'] as List<dynamic>)
          .cast<String>(),
    );
  }
}

class ConclusionSummary {
  const ConclusionSummary({
    required this.summary,
    required this.findings,
    required this.uncertainty,
    required this.suggestedNextActions,
  });

  final String summary;
  final List<RankedFinding> findings;
  final List<String> uncertainty;
  final List<String> suggestedNextActions;

  factory ConclusionSummary.fromJson(Map<String, dynamic> json) {
    return ConclusionSummary(
      summary: json['summary'] as String,
      findings: (json['findings'] as List<dynamic>)
          .map((item) => RankedFinding.fromJson(item as Map<String, dynamic>))
          .toList(),
      uncertainty: (json['uncertainty'] as List<dynamic>).cast<String>(),
      suggestedNextActions: (json['suggested_next_actions'] as List<dynamic>)
          .cast<String>(),
    );
  }
}

class AnalysisSessionSnapshot {
  const AnalysisSessionSnapshot({
    required this.sessionId,
    required this.observationId,
    required this.status,
    required this.mode,
    required this.observation,
    required this.hypotheses,
    required this.probeEvidence,
    required this.experiments,
    required this.conclusion,
  });

  final String sessionId;
  final String observationId;
  final String status;
  final String mode;
  final ObservationSummary observation;
  final List<HypothesisSummary> hypotheses;
  final List<EvidenceSummary> probeEvidence;
  final List<ExperimentSummary> experiments;
  final ConclusionSummary conclusion;

  factory AnalysisSessionSnapshot.fromJson(Map<String, dynamic> json) {
    return AnalysisSessionSnapshot(
      sessionId: json['session_id'] as String,
      observationId: json['observation_id'] as String,
      status: json['status'] as String,
      mode: json['mode'] as String,
      observation: ObservationSummary.fromJson(
        json['observation'] as Map<String, dynamic>,
      ),
      hypotheses: (json['hypotheses'] as List<dynamic>)
          .map(
            (item) => HypothesisSummary.fromJson(item as Map<String, dynamic>),
          )
          .toList(),
      probeEvidence: (json['probe_evidence'] as List<dynamic>)
          .map((item) => EvidenceSummary.fromJson(item as Map<String, dynamic>))
          .toList(),
      experiments: (json['experiments'] as List<dynamic>)
          .map(
            (item) => ExperimentSummary.fromJson(item as Map<String, dynamic>),
          )
          .toList(),
      conclusion: ConclusionSummary.fromJson(
        json['conclusion'] as Map<String, dynamic>,
      ),
    );
  }
}