use std::time;
use std::collections::HashSet;

pub trait ProgrammingLanguageInterface {
  fn get_language_name(&self) -> String;
  fn get_source_file_suffix(&self) -> String;

  fn run_computation(&mut self, _request: ComputationRequest) -> ComputationResponse {
    ComputationResponse {
      main_output: Err(format!("Computation pipeline not implemented")),
      global_output_stats: GlobalOutputStats::default(),
      debug_responses: vec![],
    }
  }

  fn request_meta(&mut self, _request: LangMetaRequest) -> LangMetaResponse {
    LangMetaResponse::Custom { kind: format!("not-implemented"), value: format!("") }
  }
}

pub struct ComputationRequest<'a> {
  pub source: &'a str,
  pub debug_requests: HashSet<DebugAsk>,
}

pub struct ComputationResponse {
  pub main_output: Result<String, String>,
  pub global_output_stats: GlobalOutputStats,
  pub debug_responses: Vec<DebugResponse>,
}

#[derive(Default, Debug)]
pub struct GlobalOutputStats {
  pub total_duration: time::Duration,
  pub stage_durations: Vec<(String, time::Duration)>
}

#[derive(Debug, Clone, Hash, Eq, PartialEq, Deserialize, Serialize)]
pub enum DebugAsk {
  Timing,
  ByStage { stage_name: String, token: Option<String> },
}

impl DebugAsk {
  pub fn is_for_stage(&self, name: &str) -> bool {
    match self {
      DebugAsk::ByStage { stage_name, .. } if stage_name == name => true,
      _ => false
    }
  }
}

pub struct DebugResponse {
  pub ask: DebugAsk,
  pub value: String
}

pub enum LangMetaRequest {
  StageNames,
  Docs {
    source: String,
  },
  Custom {
    kind: String,
    value: String
  },
  ImmediateDebug(DebugAsk),
}

pub enum LangMetaResponse {
  StageNames(Vec<String>),
  Docs {
    doc_string: String,
  },
  Custom {
    kind: String,
    value: String
  },
  ImmediateDebug(DebugResponse),
}