export type Language = 'python' | 'javascript' | 'typescript' | 'java';
export type TestKind = 'unit' | 'interface' | 'ui';
export type Lang = 'tr' | 'en';

export interface Coverage {
  percent: number | null;
  covered_lines: number[];
  missed_lines: number[];
  total_lines: number;
}

export interface TestCase {
  name: string;
  status: 'passed' | 'failed' | 'error' | 'skipped';
  message: string;
}

export interface RunResult {
  compiled: boolean;
  compile_output: string;
  passed: number;
  failed: number;
  errors: number;
  skipped: number;
  total: number;
  duration_s: number;
  output: string;
  cases: TestCase[];
  coverage: Coverage;
  timed_out: boolean;
}

export interface Mutant {
  id: number;
  line: number;
  operator: string;
  original: string;
  mutated: string;
  status: 'killed' | 'survived' | 'invalid' | 'timeout' | 'pending';
  note: string;
}

export interface MutationReport {
  total: number;
  killed: number;
  survived: number;
  invalid: number;
  timeout: number;
  score: number | null;
  mutants: Mutant[];
}

export interface Analysis {
  summary: string;
  explanation: string;
  units: Array<Record<string, unknown>>;
  edge_cases: string[];
  test_plan: string[];
  risks: string[];
}

export interface IterationRecord {
  iteration: number;
  compiled: boolean;
  passed: number;
  failed: number;
  total: number;
  coverage: number | null;
  action: string;
}

export interface JobResult {
  analysis: Analysis;
  test_code: string;
  test_filename: string;
  final_run: RunResult | null;
  mutation: MutationReport | null;
  mutation_before?: MutationReport | null;
  mutation_round?: { round?: number; accepted?: boolean; score_before?: number | null; score_after?: number | null; tests_added?: number; killed_extra?: number; survivors_shown?: number };
  iterations: IterationRecord[];
  suspected_bugs: Array<{ test: string; reason: string }>;
  rejected_bug_reports?: Array<{ test: string; claim: string; verdict: string; by: string }>;
  pruned_tests?: number;
  llm_calls: number;
  tool_calls: number;
  duration_s: number;
  stop_reason: string;
  stop_reason_i18n?: Partial<Record<Lang, string>>;
  translations?: Partial<Record<Lang, Translation>>;
  compute?: Compute;
}

export interface Translation { analysis: Analysis; bug_reasons: string[]; rejected_verdicts: string[] }

export interface AgentEvent {
  seq: number;
  ts: number;
  type: string;
  phase: string | null;
  title: string;
  data: Record<string, any>;
}

export interface JobRequest {
  language: Language;
  code: string;
  test_kind: TestKind;
  html?: string | null;
  model?: string | null;
  max_iterations?: number;
  coverage_target?: number;
  run_mutation: boolean;
  max_mutants?: number;
  temperature?: number;
  title?: string;
  lang?: Lang;
  device?: Device | null;
  mutation_rounds?: number;
  extra_files?: Record<string, string>;
  source_name?: string | null;
}

export interface JobState {
  id: string;
  status: 'queued' | 'running' | 'done' | 'failed' | 'cancelled';
  created_at: number;
  request: JobRequest;
  events: AgentEvent[];
  result: JobResult | null;
  error: string | null;
  source_filename: string;
}

export interface JobSummary {
  id: string;
  status: string;
  created_at: number;
  language: Language;
  test_kind: TestKind;
  title: string;
  model: string;
  coverage: number | null;
  passed: number | null;
  total: number | null;
  mutation_score: number | null;
  iterations: number;
}

export interface Sample {
  id: string;
  title: string;
  title_en?: string;
  description_en?: string;
  language: Language;
  kind: TestKind;
  description: string;
  code: string;
  html?: string | null;
  split?: 'dev' | 'test' | 'bagimsiz';
}

export interface RunningModel {
  name: string;
  gpu_percent: number | null;
  size_gb: number;
  vram_gb: number;
  context?: number;
}

export interface Compute {
  model?: string;
  gpu_percent?: number | null;
  vram_gb?: number;
  size_gb?: number;
  tokens_per_s?: number;
  energy_wh?: number;
  gpu_util_avg?: number;
  gpu_mem_peak_gb?: number;
  provider?: string;
  device?: Device | null;
}

export type Device = 'auto' | 'gpu' | 'cpu';
export type ProviderId = 'ollama' | 'openai' | 'anthropic';

export interface ProbeResult { ok: boolean; code?: string; error?: string; seconds?: number; checked_at?: number }
export interface ModelOption { id: string; provider: ProviderId; name: string; score?: number; probe?: ProbeResult | null }

export interface CloudProvider {
  id: 'openai' | 'anthropic';
  label: string;
  connected: boolean;
  configured: boolean;
  key_hint: string;
  key_source: 'saved' | 'env' | null;
  base_url: string;
  default_url: string;
  models: { id: string; model: string; name: string; created?: string | number | null }[];
  synced_at: number | null;
  error: string | null;
  error_code?: 'auth' | 'notfound' | 'network' | 'timeout' | 'http' | 'nokey' | null;
  error_detail?: string | null;
  rejected?: boolean;
}

export interface Providers { device: Device; cloud: CloudProvider[] }

export interface Health {
  version?: string;
  ollama: { ok: boolean; url: string; models: string[]; error?: string; running?: RunningModel[] };
  providers?: Providers;
  models_all?: ModelOption[];
  automation?: AutoNotice;
  default_model: string;
  sandbox_mode: string;
  java_framework: string;
  java_coverage: boolean;
  max_iterations: number;
  coverage_target: number;
  max_mutants: number;
}

export interface Agg {
  n: number;
  completed: number;
  first_compile_rate: number | null;
  final_compile_rate: number | null;
  first_pass_rate: number | null;
  final_pass_rate: number | null;
  first_coverage: number | null;
  final_coverage: number | null;
  mutation_score: number | null;
  mutation_score_pooled: number | null;
  seeded_catch_rate: number | null;
  seeded_total: number;
  avg_iterations: number | null;
  avg_llm_calls: number | null;
  avg_duration_s: number | null;
  mutation_score_pre?: number | null;
  avg_energy_wh?: number | null;
}

export interface EvalItem {
  id: string;
  title: string;
  title_en?: string;
  stop_reason_i18n?: Partial<Record<Lang, string>>;
  language: Language;
  kind: TestKind;
  job_id: string;
  status: string;
  error: string;
  first_coverage: number | null;
  final_coverage: number | null;
  final_pass_rate: number | null;
  tests: number;
  iterations: number;
  mutation_score: number | null;
  mutation_score_pre?: number | null;
  energy_wh?: number | null;
  rep?: number;
  seeded_total: number;
  seeded_caught: number;
  duration_s: number;
  stop_reason: string;
}

export interface EvalState {
  id: string;
  created_at: number;
  status: string;
  model: string;
  label?: string;
  config: Record<string, unknown>;
  items: EvalItem[];
  summary: { overall?: Agg; by_language?: Record<string, Agg>; by_kind?: Record<string, Agg> };
}

export interface BenchItem {
  id: string;
  title: string;
  title_en?: string;
  description_en?: string;
  language: Language;
  kind: TestKind;
  description: string;
  seeded_bugs: number;
}

export interface GpuDevice {
  index: number;
  name: string | null;
  driver: string | null;
  util: number | null;
  mem_util: number | null;
  mem_used_mib: number | null;
  mem_total_mib: number | null;
  temp_c: number | null;
  power_w: number | null;
  power_limit_w: number | null;
  clock_mhz: number | null;
  clock_max_mhz: number | null;
  fan_pct: number | null;
  pstate: string | null;
}

export interface GpuStatus {
  ts: number;
  device?: Device;
  available: boolean;
  source: string | null;
  gpus: GpuDevice[];
  error: string | null;
  models: RunningModel[];
}

export interface EvalListItem { id: string; created_at: number; status: string; model: string; label?: string; n: number; summary?: Partial<Agg> }

export interface ExpStep {
  label: string; kind: 'eval' | 'judge' | 'xmut'; model: string; status: string; ablate: string[]; max_iterations: number;
  repeats: number; rule_mode: string; eval_id: string; error: string; done: number; total: number; summary?: Partial<Agg>;
}

export interface Experiment {
  id: string; created_at: number; profile: 'tam' | 'hizli' | 'deneme' | 'karsilastirma'; models: string[]; status: string; max_mutants: number;
  retryable?: { items: number; xmut: number; steps: number; total: number };
  finished_at: number; error: string; steps: ExpStep[]; items_done: number; items_total: number; percent: number;
  eta_s: number; avg_item_s: number; judge_done: number; judge_total: number;
}

export interface ExpPlan { steps: ExpStep[]; item_runs: number; items: number; eta_s: number }

export interface CompareMetric { metric: string; items: number; mean_a: number | null; mean_b: number | null; delta: number | null; p: number; a12: number | null; effect: string }
export interface CompareResult {
  a: { id: string; model: string; label: string; config: Record<string, unknown> };
  b: { id: string; model: string; label: string; config: Record<string, unknown> };
  metrics: Record<string, CompareMetric>;
  items: Array<Record<string, any>>;
}

// ---------------------------------------------------------------- Çalışma alanı otomasyonu
export type AutoStatus = 'queued' | 'running' | 'paused' | 'done' | 'cancelled' | 'failed';
export interface AutoSettings {
  model?: string | null;
  device?: Device | null;
  max_iterations: number;
  coverage_target: number;
  run_mutation: boolean;
  max_mutants: number;
  mutation_rounds: number;
  lang: Lang;
  report_langs: Lang[];
  pdf: boolean;
  model_mode?: 'single' | 'random';
  model_pool?: string[];
  seed?: number | null;
  weighted?: boolean;
}
export interface LibItem { id: string; title: string; language: Language; kind: TestKind; group: string | null;
  lines: number; helpers: number; created_at: number }
export interface LibItemIn { name: string; language: Language; kind: TestKind; code: string; html?: string | null;
  extra_files?: Record<string, string>; source_name?: string | null; group?: string | null }
export interface AutoItem {
  sample_id: string;
  title: string;
  title_en: string;
  model: string | null;
  retried_from?: string | null;
  language: Language;
  kind: TestKind;
  status: 'queued' | 'running' | 'done' | 'failed' | 'cancelled' | 'skipped';
  job_id: string | null;
  passed: number | null;
  total: number | null;
  coverage: number | null;
  mutation: number | null;
  error: string | null;
  started_at: number | null;
  finished_at: number | null;
  reports: Record<string, string>;
  pdf_error: string | null;
}
export interface AutoRun {
  id: string;
  rebuild?: { state?: 'running' | 'done' | 'partial' | 'failed'; done?: number; total?: number; error?: string | null; failed?: number };
  created_at: number;
  status: AutoStatus;
  settings: AutoSettings;
  items: AutoItem[];
  started_at: number | null;
  finished_at: number | null;
  error: string | null;
  seen: boolean;
  counts: Record<string, number>;
  total: number;
  done_n: number;
  percent: number;
  avg_item_s: number;
  eta_s: number;
  current: string | null;
  worker: boolean;
  phase?: string | null;
  checked?: boolean;
  probe?: Record<string, ProbeResult>;
  excluded?: Record<string, string>;
  shares?: Record<string, number>;
}
export interface AutoNotice {
  active: { id: string; done: number; total: number; current: [string, string] | null } | null;
  finished: { id: string; status: AutoStatus; total: number; done: number; green: number; failed: number;
    finished_at: number; duration_s: number } | null;
}

// ---------------------------------------------------------------- Kod bazında gelişim
export interface TrackRun {
  job_id: string; created_at: number; status: string; origin: 'workspace' | 'automation' | 'evaluation';
  model: string | null; provider: string; passed: number | null; total: number | null; coverage: number | null;
  mutation: number | null; mutation_before: number | null; iterations: number; duration_s: number | null;
  tokens_out: number | null; energy_wh: number | null; max_iterations: number | null; mutation_rounds: number;
  title: string | null; summary: string;
}
export interface TrackSummary {
  key: string; language: Language; kind: TestKind; source: 'sample' | 'library' | 'custom'; sample_id: string | null;
  title: string; title_en: string; lines: number; runs: number; first_at: number; last_at: number; green: number;
  models: string[];
  best: { job_id: string; coverage: number | null; mutation: number | null; passed: number | null; total: number | null; model: string | null } | null;
  last: { job_id: string; status: string; coverage: number | null; mutation: number | null; passed: number | null; total: number | null; model: string | null };
  trend: (number | null)[];
}
export interface TrackModel { model: string; runs: number; green: number; failed: number; avg_coverage: number | null;
  avg_mutation: number | null; best_mutation: number | null; avg_duration_s: number | null }
export interface TrackDetail extends Omit<TrackSummary, 'runs' | 'best' | 'last' | 'trend' | 'first_at' | 'last_at' | 'green' | 'models'> {
  runs: TrackRun[]; models: TrackModel[]; best: TrackRun | null;
  stats: { runs: number; green: number; failed: number; best_coverage: number | null; best_mutation: number | null; avg_duration_s: number | null };
}