use std::future::Future;
use std::pin::Pin;
use std::sync::Arc;

mod executor;
mod host;

use crate::HostSkillsSnapshot;
use codex_exec_server::EnvironmentAccess;
use codex_exec_server::ExecutorCapabilityDiscoverySnapshot;
use codex_exec_server::ExecutorCapabilityDiscoveryV2Snapshot;
use codex_exec_server::ResolvedSelectedCapabilityRoot;
use codex_mcp::McpResourceClient;
use codex_protocol::capabilities::SelectedCapabilityRoot;

use crate::catalog::SkillAuthority;
use crate::catalog::SkillCatalog;
use crate::catalog::SkillPackageId;
use crate::catalog::SkillProviderResult;
use crate::catalog::SkillReadResult;
use crate::catalog::SkillResourceId;
use crate::catalog::SkillSearchResult;

pub use executor::ExecutorSkillProvider;
pub(crate) use executor::attribute_executor_plugins;
pub use host::HostSkillProvider;

pub(crate) const MAX_SKILL_RESOURCE_CONTENT_BYTES: usize = 1024 * 1024;

#[derive(Clone, Debug)]
pub struct SkillListQuery {
    pub turn_id: String,
    pub executor_roots: Vec<SelectedCapabilityRoot>,
    pub resolved_executor_roots: Vec<ResolvedSelectedCapabilityRoot>,
    pub host_snapshot: Option<Arc<HostSkillsSnapshot>>,
    pub include_host_skills: bool,
    pub include_bundled_skills: bool,
    pub include_cloud_skills: bool,
    pub mcp_resources: Option<Arc<McpResourceClient>>,
    /// Present only when the opt-in high-level executor discovery path is selected.
    pub executor_capability_discovery: Option<ExecutorCapabilityDiscoverySnapshot>,
    /// Inert V2 inventories; empty when none were supplied. Existing discovery is unchanged.
    pub executor_capability_discovery_v2: Vec<ExecutorCapabilityDiscoveryV2Snapshot>,
}

/// A skill read with the source access supplied by its callback.
#[derive(Clone)]
pub struct SkillReadRequest<'a> {
    pub authority: SkillAuthority,
    pub package: SkillPackageId,
    pub resource: SkillResourceId,
    pub context: SkillReadContext<'a>,
}

/// Executor reads require callback access; other providers carry their own source context.
#[derive(Clone)]
pub enum SkillReadContext<'a> {
    Host {
        host_snapshot: Option<Arc<HostSkillsSnapshot>>,
    },
    Executor {
        fs: &'a dyn EnvironmentAccess,
    },
    Cloud {
        mcp_resources: Option<Arc<McpResourceClient>>,
    },
    Custom {
        mcp_resources: Option<Arc<McpResourceClient>>,
    },
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SkillSearchRequest {
    pub authority: SkillAuthority,
    pub package: SkillPackageId,
    pub query: String,
}

pub type SkillProviderFuture<'a, T> =
    Pin<Box<dyn Future<Output = SkillProviderResult<T>> + Send + 'a>>;

/// Source-specific skill catalog and resource access.
///
/// Implementations must preserve authority boundaries: a resource listed by a
/// provider must be read or searched through the same provider/authority rather
/// than converted into an ambient local path.
pub trait SkillProvider: Send + Sync {
    fn list(&self, query: SkillListQuery) -> SkillProviderFuture<'_, SkillCatalog>;

    fn read<'a>(
        &'a self,
        request: SkillReadRequest<'a>,
    ) -> SkillProviderFuture<'a, SkillReadResult>;

    fn search(&self, request: SkillSearchRequest) -> SkillProviderFuture<'_, SkillSearchResult>;
}