//! Named, persistable bundles of parsing/indexing rules and dashboards for a CLI app, persisted as a single `profiles.json`.
//! `Settings.profiles` only tracks lightweight name/active pointers; this module owns the actual content.
#![allow(dead_code)]

use std::collections::hash_map::DefaultHasher;
use std::collections::BTreeMap;
use std::fmt;
use std::fs;
use std::hash::{Hash, Hasher};
use std::io;
use std::path::{Path, PathBuf};
use std::time::{SystemTime, UNIX_EPOCH};

use serde::{Deserialize, Serialize};

use crate::data_value::{MetricPrimitiveKind, ParamRole, RegexToMetricPrimitiveMatcher};
use crate::engine::{DeclareMetricRequest, DeclareParamRequest, EngineHandle, EngineMessage};
use crate::settings::Settings;
use tokio::sync::oneshot;

/// Name of the profile that always exists and can't be deleted (see `ProfileStore::ensure_default`).
pub const DEFAULT_PROFILE_NAME: &str = "Default";

/// Mirrors `data_value::MetricPrimitiveKind` with `Serialize`/`Deserialize` so profiles can round-trip through JSON, since the engine-internal type only derives `Serialize`.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum ProfileMetricPrimitiveKind {
    String,
    Number,
    Timestamp,
    /// Mirrors `MetricPrimitiveKind::Duration`.
    Duration,
    /// Mirrors `MetricPrimitiveKind::Boolean`.
    Boolean,
}

impl From<MetricPrimitiveKind> for ProfileMetricPrimitiveKind {
    fn from(kind: MetricPrimitiveKind) -> Self {
        match kind {
            MetricPrimitiveKind::String => ProfileMetricPrimitiveKind::String,
            MetricPrimitiveKind::Number => ProfileMetricPrimitiveKind::Number,
            MetricPrimitiveKind::Timestamp => ProfileMetricPrimitiveKind::Timestamp,
            MetricPrimitiveKind::Duration => ProfileMetricPrimitiveKind::Duration,
            MetricPrimitiveKind::Boolean => ProfileMetricPrimitiveKind::Boolean,
        }
    }
}

impl From<ProfileMetricPrimitiveKind> for MetricPrimitiveKind {
    fn from(kind: ProfileMetricPrimitiveKind) -> Self {
        match kind {
            ProfileMetricPrimitiveKind::String => MetricPrimitiveKind::String,
            ProfileMetricPrimitiveKind::Number => MetricPrimitiveKind::Number,
            ProfileMetricPrimitiveKind::Timestamp => MetricPrimitiveKind::Timestamp,
            ProfileMetricPrimitiveKind::Duration => MetricPrimitiveKind::Duration,
            ProfileMetricPrimitiveKind::Boolean => MetricPrimitiveKind::Boolean,
        }
    }
}

/// A stored param declaration, matching `DeclareParamRequest`'s shape.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ParamDeclarationRecord {
    pub name: String,
    pub message_match_regex: String,
    pub capture_group: String,
    /// See `crate::data_value::RegexToMetricPrimitiveMatcher::json_field_path`; `#[serde(default)]`
    /// so profiles saved before this field existed still load as plain regex-capture-group params.
    #[serde(default)]
    pub json_field_path: Option<String>,
    pub kind: ProfileMetricPrimitiveKind,
}

impl From<&DeclareParamRequest> for ParamDeclarationRecord {
    fn from(request: &DeclareParamRequest) -> Self {
        ParamDeclarationRecord {
            name: request.name.clone(),
            message_match_regex: request.message_match_regex.clone(),
            capture_group: request.capture_group.clone(),
            json_field_path: request.json_field_path.clone(),
            kind: request.kind.into(),
        }
    }
}

impl From<&ParamDeclarationRecord> for DeclareParamRequest {
    fn from(record: &ParamDeclarationRecord) -> Self {
        DeclareParamRequest {
            name: record.name.clone(),
            message_match_regex: record.message_match_regex.clone(),
            capture_group: record.capture_group.clone(),
            json_field_path: record.json_field_path.clone(),
            kind: record.kind.into(),
        }
    }
}

/// A stored metric param matcher, matching `RegexToMetricPrimitiveMatcher`'s shape.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct MetricParamRecord {
    pub param_name: String,
    pub capture_group: String,
    /// See `crate::data_value::RegexToMetricPrimitiveMatcher::json_field_path`; `#[serde(default)]`
    /// so profiles saved before this field existed still load as plain regex-capture-group matchers.
    #[serde(default)]
    pub json_field_path: Option<String>,
    pub kind: ProfileMetricPrimitiveKind,
    /// See `ParamRole`; `#[serde(default)]` so profiles saved before this field existed still load, defaulting to `Label`.
    #[serde(default)]
    pub role: ParamRole,
}

/// A stored metric declaration, matching `DeclareMetricRequest`'s shape.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct MetricDeclarationRecord {
    pub name: String,
    pub message_match_regex: String,
    pub params: Vec<MetricParamRecord>,
    /// See `crate::engine::DeclareMetricRequest::matched_labels`; `#[serde(default)]` so older profiles still load.
    #[serde(default)]
    pub matched_labels: Option<std::collections::BTreeMap<String, String>>,
    /// See `crate::engine::DeclareMetricRequest::unmatched_labels`; `#[serde(default)]` so older profiles still load.
    #[serde(default)]
    pub unmatched_labels: Option<std::collections::BTreeMap<String, String>>,
}

impl From<&DeclareMetricRequest> for MetricDeclarationRecord {
    fn from(request: &DeclareMetricRequest) -> Self {
        MetricDeclarationRecord {
            name: request.name.clone(),
            message_match_regex: request.message_match_regex.clone(),
            params: request
                .params
                .iter()
                .map(|matcher| MetricParamRecord {
                    param_name: matcher.param_name.clone(),
                    capture_group: matcher.capture_group.clone(),
                    json_field_path: matcher.json_field_path.clone(),
                    kind: matcher.kind.into(),
                    role: matcher.role,
                })
                .collect(),
            matched_labels: request.matched_labels.clone(),
            unmatched_labels: request.unmatched_labels.clone(),
        }
    }
}

impl From<&MetricDeclarationRecord> for DeclareMetricRequest {
    fn from(record: &MetricDeclarationRecord) -> Self {
        DeclareMetricRequest {
            name: record.name.clone(),
            message_match_regex: record.message_match_regex.clone(),
            matched_labels: record.matched_labels.clone(),
            unmatched_labels: record.unmatched_labels.clone(),
            params: record
                .params
                .iter()
                .map(|param| RegexToMetricPrimitiveMatcher {
                    param_name: param.param_name.clone(),
                    capture_group: param.capture_group.clone(),
                    json_field_path: param.json_field_path.clone(),
                    kind: param.kind.into(),
                    role: param.role,
                })
                .collect(),
        }
    }
}

/// A chart type a dashboard panel can render; kept in sync with the frontend's `'bar' | 'line' | 'pie'` union (see `webapp/src/lib/api.ts`).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum ChartType {
    Bar,
    Line,
    Pie,
}

/// One panel within a dashboard: a PromQL query plus how to chart its result.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Panel {
    pub id: String,
    pub title: String,
    pub promql: String,
    pub chart_type: ChartType,
}

/// A named set of panels, saved as part of a profile.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Dashboard {
    pub id: String,
    pub name: String,
    #[serde(default)]
    pub panels: Vec<Panel>,
}

/// Generates an id by hashing a seed (dashboard/panel name) with the current time, avoiding a `uuid` dependency for what's otherwise an opaque string.
fn generate_id(seed: &str) -> String {
    let mut hasher = DefaultHasher::new();
    seed.hash(&mut hasher);
    let nanos = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .map(|d| d.as_nanos())
        .unwrap_or(0);
    nanos.hash(&mut hasher);
    format!("{:016x}", hasher.finish())
}

impl Dashboard {
    pub fn new(name: String) -> Dashboard {
        let id = generate_id(&name);
        Dashboard { id, name, panels: Vec::new() }
    }
}

/// Name of the metric seeded into a brand-new `Default` profile, used to drive its starter dashboard's two panels.
const SEEDED_METRIC_NAME: &str = "log_category";
const SEEDED_METRIC_LABEL: &str = "category";

/// A counter that splits every line into `category="error"`/`"other"` via `matched_labels`/`unmatched_labels` rather than a captured param, so case variants like "ERROR" collapse into one series; the `regex` crate lacks the lookaround needed to express "didn't match" any other way.
fn seeded_error_split_metric() -> MetricDeclarationRecord {
    MetricDeclarationRecord {
        name: SEEDED_METRIC_NAME.to_string(),
        message_match_regex: r"(?i)error".to_string(),
        params: Vec::new(),
        matched_labels: Some(BTreeMap::from([(SEEDED_METRIC_LABEL.to_string(), "error".to_string())])),
        unmatched_labels: Some(BTreeMap::from([(SEEDED_METRIC_LABEL.to_string(), "other".to_string())])),
    }
}

/// The starter dashboard seeded into a brand-new `Default` profile: a line chart and a pie chart, both querying the seeded error-split counter.
fn seeded_default_dashboard() -> Dashboard {
    let mut dashboard = Dashboard::new("Overview".to_string());
    dashboard.panels = vec![
        Panel {
            id: generate_id("error-volume-line"),
            title: "Error vs. non-error volume".to_string(),
            promql: format!("sum(rate({SEEDED_METRIC_NAME}[1m])) by ({SEEDED_METRIC_LABEL})"),
            chart_type: ChartType::Line,
        },
        Panel {
            id: generate_id("error-volume-pie"),
            title: "Error vs. non-error ratio".to_string(),
            promql: SEEDED_METRIC_NAME.to_string(),
            chart_type: ChartType::Pie,
        },
    ];
    dashboard
}

/// A named bundle of parsing/indexing rules for a particular CLI app, plus any saved dashboards.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Profile {
    pub name: String,
    #[serde(default)]
    pub params: Vec<ParamDeclarationRecord>,
    #[serde(default)]
    pub metrics: Vec<MetricDeclarationRecord>,
    #[serde(default)]
    pub dashboards: Vec<Dashboard>,
}

impl Profile {
    pub fn new(name: String) -> Profile {
        Profile {
            name,
            params: Vec::new(),
            metrics: Vec::new(),
            dashboards: Vec::new(),
        }
    }
}

/// Replays every param/metric declaration stored in `profile` into `engine` (used on startup and in tests); any rejected declaration or send/recv failure is logged to stderr and skipped rather than panicking.
pub async fn load_into_engine(engine: &EngineHandle, profile: &Profile) {
    for record in &profile.params {
        let (respond_to, response) = oneshot::channel();
        let request: DeclareParamRequest = record.into();
        let name = request.name.clone();
        if engine
            .send(EngineMessage::DeclareParam { request, respond_to })
            .await
            .is_err()
        {
            eprintln!("warning: engine unavailable while loading profile '{}'", profile.name);
            return;
        }
        match response.await {
            Ok(Ok(())) => {}
            Ok(Err(err)) => eprintln!(
                "warning: profile '{}' param declaration '{name}' rejected by engine: {err}",
                profile.name
            ),
            Err(_) => eprintln!(
                "warning: engine dropped response while declaring param '{name}' from profile '{}'",
                profile.name
            ),
        }
    }

    for record in &profile.metrics {
        let (respond_to, response) = oneshot::channel();
        let request: DeclareMetricRequest = record.into();
        let name = request.name.clone();
        if engine
            .send(EngineMessage::DeclareMetric { request, respond_to })
            .await
            .is_err()
        {
            eprintln!("warning: engine unavailable while loading profile '{}'", profile.name);
            return;
        }
        match response.await {
            Ok(Ok(())) => {}
            Ok(Err(err)) => eprintln!(
                "warning: profile '{}' metric declaration '{name}' rejected by engine: {err}",
                profile.name
            ),
            Err(_) => eprintln!(
                "warning: engine dropped response while declaring metric '{name}' from profile '{}'",
                profile.name
            ),
        }
    }
}

/// Error returned by `ProfileStore` mutations and lookups.
#[derive(Debug)]
pub enum ProfileError {
    /// No profile with the given name exists.
    NotFound,
    /// A profile with the given name already exists.
    DuplicateName,
    /// The `Default` profile can't be deleted — there must always be at least one profile to fall back to.
    CannotDeleteDefault,
    /// Underlying I/O failure reading/writing the profile store or settings file.
    Io(io::Error),
}

impl fmt::Display for ProfileError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ProfileError::NotFound => write!(f, "no profile with that name"),
            ProfileError::DuplicateName => write!(f, "a profile with that name already exists"),
            ProfileError::CannotDeleteDefault => write!(f, "the Default profile cannot be deleted"),
            ProfileError::Io(err) => write!(f, "I/O error: {err}"),
        }
    }
}

impl std::error::Error for ProfileError {}

impl From<io::Error> for ProfileError {
    fn from(err: io::Error) -> Self {
        ProfileError::Io(err)
    }
}

/// Resolves `settings.profiles.profiles_dir` relative to `settings_path`'s parent directory (or as absolute if it already is one).
pub fn resolve_profiles_dir(settings: &Settings, settings_path: &Path) -> PathBuf {
    let profiles_dir = Path::new(&settings.profiles.profiles_dir);
    if profiles_dir.is_absolute() {
        profiles_dir.to_path_buf()
    } else {
        settings_path
            .parent()
            .map(|parent| parent.join(profiles_dir))
            .unwrap_or_else(|| profiles_dir.to_path_buf())
    }
}

/// Path to the single file holding all profiles, within `profiles_dir`.
pub fn profiles_store_path(profiles_dir: &Path) -> PathBuf {
    profiles_dir.join("profiles.json")
}

/// On-disk collection of all known profiles, persisted as a single JSON file.
#[derive(Debug, Clone, Default)]
pub struct ProfileStore {
    profiles: Vec<Profile>,
}

impl ProfileStore {
    /// Loads the store from `store_path`; a missing or unreadable/unparsable file is treated as an empty store rather than failing startup.
    pub fn load(store_path: &Path) -> ProfileStore {
        match fs::read_to_string(store_path) {
            Ok(contents) => match serde_json::from_str::<Vec<Profile>>(&contents) {
                Ok(profiles) => ProfileStore { profiles },
                Err(err) => {
                    eprintln!(
                        "warning: failed to parse profile store at {}: {err}; using empty store",
                        store_path.display()
                    );
                    ProfileStore::default()
                }
            },
            Err(err) if err.kind() == io::ErrorKind::NotFound => ProfileStore::default(),
            Err(err) => {
                eprintln!(
                    "warning: failed to read profile store at {}: {err}; using empty store",
                    store_path.display()
                );
                ProfileStore::default()
            }
        }
    }

    /// Persists the store to `store_path` as pretty-printed JSON, creating any missing parent directories first.
    pub fn save(&self, store_path: &Path) -> io::Result<()> {
        if let Some(parent) = store_path.parent() {
            fs::create_dir_all(parent)?;
        }
        let contents = serde_json::to_string_pretty(&self.profiles)
            .map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))?;
        fs::write(store_path, contents)
    }

    pub fn list(&self) -> &[Profile] {
        &self.profiles
    }

    pub fn get(&self, name: &str) -> Option<&Profile> {
        self.profiles.iter().find(|p| p.name == name)
    }

    /// Creates a new profile named `name` (persisting store and settings), copying the active profile's params/metrics/dashboards as a starting point rather than starting blank. Fails with `DuplicateName` if the name exists.
    pub fn create(
        &mut self,
        store_path: &Path,
        settings: &mut Settings,
        settings_path: &Path,
        name: String,
    ) -> Result<(), ProfileError> {
        if self.get(&name).is_some() {
            return Err(ProfileError::DuplicateName);
        }
        let mut profile = Profile::new(name.clone());
        if let Some(active) = settings.profiles.active_profile.as_deref().and_then(|n| self.get(n)) {
            profile.params = active.params.clone();
            profile.metrics = active.metrics.clone();
            profile.dashboards = active.dashboards.clone();
        }
        self.profiles.push(profile);
        self.save(store_path)?;

        if !settings.profiles.names.contains(&name) {
            settings.profiles.names.push(name);
        }
        settings.save(settings_path)?;
        Ok(())
    }

    /// Deletes the profile named `name` (persisting store and settings), clearing `active_profile` if it was active. Fails with `NotFound`, or `CannotDeleteDefault` for the `Default` profile.
    pub fn delete(
        &mut self,
        store_path: &Path,
        settings: &mut Settings,
        settings_path: &Path,
        name: &str,
    ) -> Result<(), ProfileError> {
        if name == DEFAULT_PROFILE_NAME {
            return Err(ProfileError::CannotDeleteDefault);
        }
        let index = self.profiles.iter().position(|p| p.name == name).ok_or(ProfileError::NotFound)?;
        self.profiles.remove(index);
        self.save(store_path)?;

        settings.profiles.names.retain(|n| n != name);
        if settings.profiles.active_profile.as_deref() == Some(name) {
            settings.profiles.active_profile = None;
        }
        settings.save(settings_path)?;
        Ok(())
    }

    /// Ensures a `Default` profile exists (seeding a starter dashboard/metric only on first creation), is tracked in `settings.profiles.names`, and falls back to active if nothing else is. Called once on startup before anything else touches profiles.
    pub fn ensure_default(
        &mut self,
        store_path: &Path,
        settings: &mut Settings,
        settings_path: &Path,
    ) -> Result<(), ProfileError> {
        if self.get(DEFAULT_PROFILE_NAME).is_none() {
            let mut profile = Profile::new(DEFAULT_PROFILE_NAME.to_string());
            profile.metrics.push(seeded_error_split_metric());
            profile.dashboards.push(seeded_default_dashboard());
            self.profiles.push(profile);
            self.save(store_path)?;
        }
        if !settings.profiles.names.iter().any(|n| n == DEFAULT_PROFILE_NAME) {
            settings.profiles.names.push(DEFAULT_PROFILE_NAME.to_string());
        }
        if settings.profiles.active_profile.is_none() {
            settings.profiles.active_profile = Some(DEFAULT_PROFILE_NAME.to_string());
        }
        settings.save(settings_path)?;
        Ok(())
    }

    /// Sets (or clears, with `None`) the active profile in `settings`. Fails with `NotFound` if `name` is `Some` and no such profile exists. Doesn't itself reload declarations into a running engine — that happens on next startup via `load_into_engine`.
    pub fn set_active(
        &self,
        settings: &mut Settings,
        settings_path: &Path,
        name: Option<String>,
    ) -> Result<(), ProfileError> {
        if let Some(name) = &name {
            if self.get(name).is_none() {
                return Err(ProfileError::NotFound);
            }
        }
        settings.profiles.active_profile = name;
        settings.save(settings_path)?;
        Ok(())
    }

    /// Records/updates a declared param into `profile_name`'s stored declarations (matched by param name), persisting the store. Intended to be called by the HTTP API alongside declaring against the engine, so declarations survive a restart.
    pub fn record_param_declaration(
        &mut self,
        store_path: &Path,
        profile_name: &str,
        request: &DeclareParamRequest,
    ) -> Result<(), ProfileError> {
        let profile = self
            .profiles
            .iter_mut()
            .find(|p| p.name == profile_name)
            .ok_or(ProfileError::NotFound)?;
        let record: ParamDeclarationRecord = request.into();
        match profile.params.iter_mut().find(|r| r.name == record.name) {
            Some(existing) => *existing = record,
            None => profile.params.push(record),
        }
        self.save(store_path)?;
        Ok(())
    }

    /// Records/updates a declared metric into `profile_name`'s stored declarations (matched by metric name), persisting the store; same integration intent as `record_param_declaration`.
    pub fn record_metric_declaration(
        &mut self,
        store_path: &Path,
        profile_name: &str,
        request: &DeclareMetricRequest,
    ) -> Result<(), ProfileError> {
        let profile = self
            .profiles
            .iter_mut()
            .find(|p| p.name == profile_name)
            .ok_or(ProfileError::NotFound)?;
        let record: MetricDeclarationRecord = request.into();
        match profile.metrics.iter_mut().find(|r| r.name == record.name) {
            Some(existing) => *existing = record,
            None => profile.metrics.push(record),
        }
        self.save(store_path)?;
        Ok(())
    }

    /// Same as `record_metric_declaration`, for an in-place edit that may rename the metric: drops any persisted record under `old_name` first (when it differs from the new name) so a rename doesn't leave a stale duplicate declaration behind, then upserts by the new name as usual.
    pub fn record_metric_declaration_update(
        &mut self,
        store_path: &Path,
        profile_name: &str,
        old_name: &str,
        request: &DeclareMetricRequest,
    ) -> Result<(), ProfileError> {
        let profile = self
            .profiles
            .iter_mut()
            .find(|p| p.name == profile_name)
            .ok_or(ProfileError::NotFound)?;
        if old_name != request.name {
            profile.metrics.retain(|r| r.name != old_name);
        }
        let record: MetricDeclarationRecord = request.into();
        match profile.metrics.iter_mut().find(|r| r.name == record.name) {
            Some(existing) => *existing = record,
            None => profile.metrics.push(record),
        }
        self.save(store_path)?;
        Ok(())
    }

    /// Lists the dashboards saved on `profile_name`; fails with `NotFound` if it doesn't exist.
    pub fn list_dashboards(&self, profile_name: &str) -> Result<&[Dashboard], ProfileError> {
        let profile = self.get(profile_name).ok_or(ProfileError::NotFound)?;
        Ok(&profile.dashboards)
    }

    /// Creates a new, empty dashboard named `name` on `profile_name`, persisting the store; fails with `NotFound` if the profile doesn't exist.
    pub fn create_dashboard(
        &mut self,
        store_path: &Path,
        profile_name: &str,
        name: String,
    ) -> Result<Dashboard, ProfileError> {
        let profile = self
            .profiles
            .iter_mut()
            .find(|p| p.name == profile_name)
            .ok_or(ProfileError::NotFound)?;
        let dashboard = Dashboard::new(name);
        profile.dashboards.push(dashboard.clone());
        self.save(store_path)?;
        Ok(dashboard)
    }

    /// Replaces the dashboard identified by `dashboard_id` with `dashboard`, persisting the store; `dashboard.id` is forced to `dashboard_id` so a caller can't change a dashboard's identity through this call.
    pub fn save_dashboard(
        &mut self,
        store_path: &Path,
        profile_name: &str,
        dashboard_id: &str,
        mut dashboard: Dashboard,
    ) -> Result<Dashboard, ProfileError> {
        let profile = self
            .profiles
            .iter_mut()
            .find(|p| p.name == profile_name)
            .ok_or(ProfileError::NotFound)?;
        let existing = profile
            .dashboards
            .iter_mut()
            .find(|d| d.id == dashboard_id)
            .ok_or(ProfileError::NotFound)?;
        dashboard.id = dashboard_id.to_string();
        *existing = dashboard.clone();
        self.save(store_path)?;
        Ok(dashboard)
    }

    /// Deletes the dashboard identified by `dashboard_id` from `profile_name`, persisting the store; fails with `NotFound` if either doesn't exist.
    pub fn delete_dashboard(
        &mut self,
        store_path: &Path,
        profile_name: &str,
        dashboard_id: &str,
    ) -> Result<(), ProfileError> {
        let profile = self
            .profiles
            .iter_mut()
            .find(|p| p.name == profile_name)
            .ok_or(ProfileError::NotFound)?;
        let index = profile
            .dashboards
            .iter()
            .position(|d| d.id == dashboard_id)
            .ok_or(ProfileError::NotFound)?;
        profile.dashboards.remove(index);
        self.save(store_path)?;
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::data_value::MetricPrimitiveKind;
    use crate::dto::LogsParams;
    use crate::engine::{EngineMessage, EngineQuery, EngineResponse, IngestedLine};
    use crate::timestamp::Timestamp;
    use tokio::sync::mpsc;

    fn param_request(name: &str, pattern: &str, capture_group: &str) -> DeclareParamRequest {
        DeclareParamRequest {
            name: name.to_string(),
            message_match_regex: pattern.to_string(),
            capture_group: capture_group.to_string(),
            json_field_path: None,
            kind: MetricPrimitiveKind::String,
        }
    }

    fn metric_request(name: &str, pattern: &str, param_name: &str, capture_group: &str) -> DeclareMetricRequest {
        DeclareMetricRequest {
            name: name.to_string(),
            message_match_regex: pattern.to_string(),
            matched_labels: None,
            unmatched_labels: None,
            params: vec![RegexToMetricPrimitiveMatcher {
                param_name: param_name.to_string(),
                capture_group: capture_group.to_string(),
                json_field_path: None,
                kind: MetricPrimitiveKind::Number,
                role: ParamRole::Label,
            }],
        }
    }

    async fn ask(engine: &EngineHandle, query: EngineQuery) -> EngineResponse {
        let (respond_to, response) = oneshot::channel();
        engine.send(EngineMessage::Query { query, respond_to }).await.unwrap();
        response.await.unwrap()
    }

    #[test]
    fn resolve_profiles_dir_is_relative_to_settings_parent() {
        let settings_path = Path::new("/config/ottyl/settings.json");
        let mut settings = Settings::default();
        settings.profiles.profiles_dir = "profiles".to_string();

        let dir = resolve_profiles_dir(&settings, settings_path);
        assert_eq!(dir, Path::new("/config/ottyl/profiles"));
    }

    #[test]
    fn resolve_profiles_dir_respects_absolute_path() {
        let settings_path = Path::new("/config/ottyl/settings.json");
        let mut settings = Settings::default();
        settings.profiles.profiles_dir = "/elsewhere/profiles".to_string();

        let dir = resolve_profiles_dir(&settings, settings_path);
        assert_eq!(dir, Path::new("/elsewhere/profiles"));
    }

    #[test]
    fn create_list_get_delete_round_trip() {
        let dir = tempfile::tempdir().unwrap();
        let store_path = dir.path().join("profiles.json");
        let settings_path = dir.path().join("settings.json");
        let mut settings = Settings::default();

        let mut store = ProfileStore::load(&store_path);
        store.create(&store_path, &mut settings, &settings_path, "web".to_string()).unwrap();
        store.create(&store_path, &mut settings, &settings_path, "worker".to_string()).unwrap();

        assert_eq!(store.list().len(), 2);
        assert!(store.get("web").is_some());
        assert_eq!(settings.profiles.names, vec!["web".to_string(), "worker".to_string()]);

        let dup = store.create(&store_path, &mut settings, &settings_path, "web".to_string());
        assert!(matches!(dup, Err(ProfileError::DuplicateName)));

        // Reload from disk: profiles and settings both persisted.
        let reloaded = ProfileStore::load(&store_path);
        assert_eq!(reloaded.list().len(), 2);
        let reloaded_settings = Settings::load(&settings_path);
        assert_eq!(reloaded_settings.profiles.names, settings.profiles.names);

        store.delete(&store_path, &mut settings, &settings_path, "worker").unwrap();
        assert!(store.get("worker").is_none());
        assert_eq!(settings.profiles.names, vec!["web".to_string()]);

        let missing = store.delete(&store_path, &mut settings, &settings_path, "worker");
        assert!(matches!(missing, Err(ProfileError::NotFound)));
    }

    #[test]
    fn ensure_default_creates_default_and_activates_it_once() {
        let dir = tempfile::tempdir().unwrap();
        let store_path = dir.path().join("profiles.json");
        let settings_path = dir.path().join("settings.json");
        let mut settings = Settings::default();

        let mut store = ProfileStore::load(&store_path);
        store.ensure_default(&store_path, &mut settings, &settings_path).unwrap();

        assert!(store.get(DEFAULT_PROFILE_NAME).is_some());
        assert!(settings.profiles.names.contains(&DEFAULT_PROFILE_NAME.to_string()));
        assert_eq!(settings.profiles.active_profile, Some(DEFAULT_PROFILE_NAME.to_string()));

        // Idempotent: doesn't duplicate the profile or clobber an already-active (non-Default) profile.
        store.create(&store_path, &mut settings, &settings_path, "web".to_string()).unwrap();
        store.set_active(&mut settings, &settings_path, Some("web".to_string())).unwrap();
        store.ensure_default(&store_path, &mut settings, &settings_path).unwrap();

        assert_eq!(store.list().iter().filter(|p| p.name == DEFAULT_PROFILE_NAME).count(), 1);
        assert_eq!(settings.profiles.active_profile, Some("web".to_string()));
    }

    #[test]
    fn ensure_default_seeds_starter_dashboard_only_on_creation() {
        let dir = tempfile::tempdir().unwrap();
        let store_path = dir.path().join("profiles.json");
        let settings_path = dir.path().join("settings.json");
        let mut settings = Settings::default();

        let mut store = ProfileStore::load(&store_path);
        store.ensure_default(&store_path, &mut settings, &settings_path).unwrap();

        let default_profile = store.get(DEFAULT_PROFILE_NAME).unwrap();
        assert_eq!(default_profile.metrics.len(), 1);
        assert_eq!(default_profile.metrics[0].name, SEEDED_METRIC_NAME);
        assert_eq!(
            default_profile.metrics[0].matched_labels,
            Some(BTreeMap::from([(SEEDED_METRIC_LABEL.to_string(), "error".to_string())]))
        );
        assert_eq!(
            default_profile.metrics[0].unmatched_labels,
            Some(BTreeMap::from([(SEEDED_METRIC_LABEL.to_string(), "other".to_string())]))
        );
        assert_eq!(default_profile.dashboards.len(), 1);
        let dashboard = &default_profile.dashboards[0];
        assert_eq!(dashboard.panels.len(), 2);
        assert!(dashboard
            .panels
            .iter()
            .any(|p| p.chart_type == ChartType::Line && p.promql.contains(SEEDED_METRIC_NAME)));
        assert!(dashboard.panels.iter().any(|p| p.chart_type == ChartType::Pie && p.promql == SEEDED_METRIC_NAME));

        // Reload (simulating a restart) and ensure_default again: must not re-seed or duplicate.
        let mut store = ProfileStore::load(&store_path);
        store.ensure_default(&store_path, &mut settings, &settings_path).unwrap();
        let default_profile = store.get(DEFAULT_PROFILE_NAME).unwrap();
        assert_eq!(default_profile.metrics.len(), 1);
        assert_eq!(default_profile.dashboards.len(), 1);
    }

    #[tokio::test]
    async fn seeded_metric_renders_real_error_vs_other_data() {
        use crate::engine::{self, EngineMessage, EngineQuery, EngineResponse, IngestedLine};
        use crate::timestamp::Timestamp;
        use tokio::sync::mpsc;

        let dir = tempfile::tempdir().unwrap();
        let store_path = dir.path().join("profiles.json");
        let settings_path = dir.path().join("settings.json");
        let mut settings = Settings::default();
        let mut store = ProfileStore::load(&store_path);
        store.ensure_default(&store_path, &mut settings, &settings_path).unwrap();
        let default_profile = store.get(DEFAULT_PROFILE_NAME).unwrap().clone();

        let (engine_tx, engine_rx) = mpsc::channel(128);
        let settings_handle = std::sync::Arc::new(std::sync::Mutex::new(settings.clone()));
        tokio::spawn(engine::run(engine_rx, settings_handle));
        load_into_engine(&engine_tx, &default_profile).await;

        for (sequence, text) in [(0u64, "all good"), (1, "an ERROR happened"), (2, "fine again")] {
            engine_tx
                .send(EngineMessage::Ingest(IngestedLine {
                    sequence,
                    timestamp: Timestamp::from_millis(sequence as i64),
                    text: text.to_string(),
                }))
                .await
                .unwrap();
        }

        let response = ask(
            &engine_tx,
            EngineQuery::Promql { query: SEEDED_METRIC_NAME.to_string(), start_ms: None, end_ms: None },
        )
        .await;
        let EngineResponse::Promql(Ok(mut series)) = response else {
            panic!("expected a successful Promql response");
        };
        series.sort_by(|a, b| a.labels.get(SEEDED_METRIC_LABEL).cmp(&b.labels.get(SEEDED_METRIC_LABEL)));

        assert_eq!(series.len(), 2);
        assert_eq!(series[0].labels.get(SEEDED_METRIC_LABEL).map(String::as_str), Some("error"));
        assert_eq!(series[0].points.len(), 1);
        assert_eq!(series[1].labels.get(SEEDED_METRIC_LABEL).map(String::as_str), Some("other"));
        assert_eq!(series[1].points.len(), 2);
    }

    #[test]
    fn default_profile_cannot_be_deleted() {
        let dir = tempfile::tempdir().unwrap();
        let store_path = dir.path().join("profiles.json");
        let settings_path = dir.path().join("settings.json");
        let mut settings = Settings::default();

        let mut store = ProfileStore::load(&store_path);
        store.ensure_default(&store_path, &mut settings, &settings_path).unwrap();

        let err = store.delete(&store_path, &mut settings, &settings_path, DEFAULT_PROFILE_NAME);
        assert!(matches!(err, Err(ProfileError::CannotDeleteDefault)));
        assert!(store.get(DEFAULT_PROFILE_NAME).is_some());
    }

    #[test]
    fn create_copies_the_active_profile() {
        let dir = tempfile::tempdir().unwrap();
        let store_path = dir.path().join("profiles.json");
        let settings_path = dir.path().join("settings.json");
        let mut settings = Settings::default();

        let mut store = ProfileStore::load(&store_path);
        store.create(&store_path, &mut settings, &settings_path, "web".to_string()).unwrap();
        let param_req = param_request("level", r"level=(?P<level>\w+)", "level");
        store.record_param_declaration(&store_path, "web", &param_req).unwrap();
        store.create_dashboard(&store_path, "web", "Overview".to_string()).unwrap();
        store.set_active(&mut settings, &settings_path, Some("web".to_string())).unwrap();

        store.create(&store_path, &mut settings, &settings_path, "web-copy".to_string()).unwrap();
        let copy = store.get("web-copy").unwrap();
        assert_eq!(copy.params, store.get("web").unwrap().params);
        assert_eq!(copy.dashboards, store.get("web").unwrap().dashboards);

        // With no active profile, new profiles start empty as before.
        store.set_active(&mut settings, &settings_path, None).unwrap();
        store.create(&store_path, &mut settings, &settings_path, "blank".to_string()).unwrap();
        let blank = store.get("blank").unwrap();
        assert!(blank.params.is_empty());
        assert!(blank.dashboards.is_empty());
    }

    #[test]
    fn set_active_updates_and_persists_settings() {
        let dir = tempfile::tempdir().unwrap();
        let store_path = dir.path().join("profiles.json");
        let settings_path = dir.path().join("settings.json");
        let mut settings = Settings::default();

        let mut store = ProfileStore::load(&store_path);
        store.create(&store_path, &mut settings, &settings_path, "web".to_string()).unwrap();
        store.create(&store_path, &mut settings, &settings_path, "worker".to_string()).unwrap();

        store.set_active(&mut settings, &settings_path, Some("web".to_string())).unwrap();
        assert_eq!(settings.profiles.active_profile, Some("web".to_string()));

        // Switching to another known profile works and persists.
        store.set_active(&mut settings, &settings_path, Some("worker".to_string())).unwrap();
        let reloaded = Settings::load(&settings_path);
        assert_eq!(reloaded.profiles.active_profile, Some("worker".to_string()));

        // Setting an unknown profile active is rejected, leaving the previous value.
        let err = store.set_active(&mut settings, &settings_path, Some("ghost".to_string()));
        assert!(matches!(err, Err(ProfileError::NotFound)));
        assert_eq!(settings.profiles.active_profile, Some("worker".to_string()));

        // Clearing the active profile works.
        store.set_active(&mut settings, &settings_path, None).unwrap();
        assert_eq!(settings.profiles.active_profile, None);
    }

    #[test]
    fn record_param_and_metric_declarations_persist_into_profile() {
        let dir = tempfile::tempdir().unwrap();
        let store_path = dir.path().join("profiles.json");
        let settings_path = dir.path().join("settings.json");
        let mut settings = Settings::default();

        let mut store = ProfileStore::load(&store_path);
        store.create(&store_path, &mut settings, &settings_path, "web".to_string()).unwrap();

        let param_req = param_request("level", r"level=(?P<level>\w+)", "level");
        store.record_param_declaration(&store_path, "web", &param_req).unwrap();

        let metric_req = metric_request(
            "requests",
            r"duration=(?P<duration>\d+)",
            "duration",
            "duration",
        );
        store.record_metric_declaration(&store_path, "web", &metric_req).unwrap();

        let profile = store.get("web").unwrap();
        assert_eq!(profile.params.len(), 1);
        assert_eq!(profile.params[0].name, "level");
        assert_eq!(profile.metrics.len(), 1);
        assert_eq!(profile.metrics[0].name, "requests");

        // Re-declaring the same name updates in place rather than duplicating.
        let param_req_v2 = param_request("level", r"lvl=(?P<level>\w+)", "level");
        store.record_param_declaration(&store_path, "web", &param_req_v2).unwrap();
        let profile = store.get("web").unwrap();
        assert_eq!(profile.params.len(), 1);
        assert_eq!(profile.params[0].message_match_regex, r"lvl=(?P<level>\w+)");

        // Reload from disk: recorded declarations survive a restart.
        let reloaded = ProfileStore::load(&store_path);
        let profile = reloaded.get("web").unwrap();
        assert_eq!(profile.params.len(), 1);
        assert_eq!(profile.metrics.len(), 1);
    }

    /// Acceptance criterion: declaring params/metrics, "restarting" (reloading the store from disk), and replaying into a fresh engine reproduces the same declarations and still ingests lines, without re-declaring by hand.
    #[tokio::test]
    async fn profile_round_trip_reproduces_declarations_in_fresh_engine() {
        let dir = tempfile::tempdir().unwrap();
        let store_path = dir.path().join("profiles.json");
        let settings_path = dir.path().join("settings.json");
        let mut settings = Settings::default();

        // Declare directly into a profile, as the HTTP API will do via the `record_*_declaration` hooks.
        let mut store = ProfileStore::load(&store_path);
        store.create(&store_path, &mut settings, &settings_path, "web".to_string()).unwrap();
        store
            .record_param_declaration(
                &store_path,
                "web",
                &param_request("level", r"level=(?P<level>\w+)", "level"),
            )
            .unwrap();
        store
            .record_metric_declaration(
                &store_path,
                "web",
                &metric_request(
                    "requests",
                    r"request duration=(?P<duration>\d+)",
                    "duration",
                    "duration",
                ),
            )
            .unwrap();
        store.set_active(&mut settings, &settings_path, Some("web".to_string())).unwrap();

        // Simulate a restart: drop everything in memory, reload from disk.
        drop(store);
        drop(settings);
        let settings = Settings::load(&settings_path);
        let active_name = settings.profiles.active_profile.clone().unwrap();
        let reloaded_store = ProfileStore::load(&store_path);
        let profile = reloaded_store.get(&active_name).unwrap().clone();

        // Spawn a fresh engine and replay the profile's declarations into it.
        let (engine_tx, engine_rx) = mpsc::channel(16);
        let settings_handle = std::sync::Arc::new(std::sync::Mutex::new(settings.clone()));
        tokio::spawn(crate::engine::run(engine_rx, settings_handle));
        load_into_engine(&engine_tx, &profile).await;

        // Ingest a line and confirm the engine works with the replayed declarations (no re-declaration needed).
        engine_tx
            .send(EngineMessage::Ingest(IngestedLine {
                sequence: 0,
                timestamp: Timestamp::from_millis(0),
                text: "level=info request duration=42".to_string(),
            }))
            .await
            .unwrap();

        let params = match ask(&engine_tx, EngineQuery::ParamDeclarations).await {
            EngineResponse::ParamDeclarations(params) => params,
            _ => panic!("unexpected response"),
        };
        assert_eq!(params.len(), 1);
        assert_eq!(params[0].name, "level");
        assert_eq!(params[0].message_match_regex, r"level=(?P<level>\w+)");
        assert_eq!(params[0].capture_group, "level");
        assert!(matches!(params[0].kind, MetricPrimitiveKind::String));

        let metrics = match ask(&engine_tx, EngineQuery::MetricDeclarations).await {
            EngineResponse::MetricDeclarations(metrics) => metrics,
            _ => panic!("unexpected response"),
        };
        assert_eq!(metrics.len(), 1);
        assert_eq!(metrics[0].name, "requests");
        assert_eq!(metrics[0].message_match_regex, r"request duration=(?P<duration>\d+)");
        assert_eq!(metrics[0].params.len(), 1);
        assert_eq!(metrics[0].params[0].param_name, "duration");

        let logs = match ask(
            &engine_tx,
            EngineQuery::Logs(LogsParams {
                since_sequence: None,
                start_ms: None,
                end_ms: None,
                limit: None,
                filter: None,
            }),
        )
        .await
        {
            EngineResponse::Logs(logs) => logs,
            _ => panic!("unexpected response"),
        };
        assert_eq!(logs.len(), 1);
        assert_eq!(logs[0].text, "level=info request duration=42");
    }

    /// Acceptance criterion: a dashboard (with a panel) survives reloading the profile store from disk.
    #[test]
    fn dashboard_create_save_delete_round_trip_and_persists_across_reload() {
        let dir = tempfile::tempdir().unwrap();
        let store_path = dir.path().join("profiles.json");
        let settings_path = dir.path().join("settings.json");
        let mut settings = Settings::default();

        let mut store = ProfileStore::load(&store_path);
        store.create(&store_path, &mut settings, &settings_path, "web".to_string()).unwrap();

        let dashboard = store.create_dashboard(&store_path, "web", "Overview".to_string()).unwrap();
        assert_eq!(dashboard.name, "Overview");
        assert!(dashboard.panels.is_empty());

        let mut with_panel = dashboard.clone();
        with_panel.panels.push(Panel {
            id: "panel-1".to_string(),
            title: "Requests".to_string(),
            promql: r#"requests{path="/a"}"#.to_string(),
            chart_type: ChartType::Line,
        });
        let saved = store
            .save_dashboard(&store_path, "web", &dashboard.id, with_panel)
            .unwrap();
        assert_eq!(saved.panels.len(), 1);
        assert_eq!(saved.id, dashboard.id);

        // Simulate a restart: drop and reload from disk.
        drop(store);
        let reloaded = ProfileStore::load(&store_path);
        let dashboards = reloaded.list_dashboards("web").unwrap();
        assert_eq!(dashboards.len(), 1);
        assert_eq!(dashboards[0].name, "Overview");
        assert_eq!(dashboards[0].panels.len(), 1);
        assert_eq!(dashboards[0].panels[0].promql, r#"requests{path="/a"}"#);

        // Deleting removes it, and that too persists.
        let mut reloaded = reloaded;
        reloaded.delete_dashboard(&store_path, "web", &dashboard.id).unwrap();
        assert!(reloaded.list_dashboards("web").unwrap().is_empty());
        let reloaded_again = ProfileStore::load(&store_path);
        assert!(reloaded_again.list_dashboards("web").unwrap().is_empty());

        // Unknown profile/dashboard both fail with NotFound.
        assert!(matches!(
            reloaded_again.list_dashboards("ghost"),
            Err(ProfileError::NotFound)
        ));
    }
}