use crate::cultnet::EpiphanyFreshnessSurface;
use crate::cultnet::EpiphanyGraphFreshnessStatus;
use crate::cultnet::EpiphanyInvalidationStatus;
use crate::cultnet::EpiphanyJobKind;
use crate::cultnet::EpiphanyJobStatus;
use crate::cultnet::EpiphanyJobView;
use crate::cultnet::EpiphanyReorientAction;
use crate::cultnet::EpiphanyReorientCheckpointStatus;
use crate::cultnet::EpiphanyReorientDecision;
use crate::cultnet::EpiphanyReorientFreshnessStatus;
use crate::cultnet::EpiphanyReorientPressureLevel;
use crate::cultnet::EpiphanyReorientReason;
use crate::cultnet::EpiphanyReorientStateStatus;
use crate::cultnet::EpiphanyRetrievalFreshnessStatus;
use crate::cultnet::EpiphanySurfaceSource;
use codex_app_server_protocol::ThreadEpiphanyContextParams;
use codex_app_server_protocol::ThreadEpiphanyDistillParams;
use codex_app_server_protocol::ThreadEpiphanyFreshnessResponse;
use codex_app_server_protocol::ThreadEpiphanyFreshnessSource;
use codex_app_server_protocol::ThreadEpiphanyGraphFreshness;
use codex_app_server_protocol::ThreadEpiphanyGraphFreshnessStatus;
use codex_app_server_protocol::ThreadEpiphanyGraphQuery;
use codex_app_server_protocol::ThreadEpiphanyGraphQueryDirection;
use codex_app_server_protocol::ThreadEpiphanyGraphQueryKind;
use codex_app_server_protocol::ThreadEpiphanyInvalidationInput;
use codex_app_server_protocol::ThreadEpiphanyInvalidationStatus;
use codex_app_server_protocol::ThreadEpiphanyJob;
use codex_app_server_protocol::ThreadEpiphanyJobKind;
use codex_app_server_protocol::ThreadEpiphanyJobStatus;
use codex_app_server_protocol::ThreadEpiphanyPressureLevel;
use codex_app_server_protocol::ThreadEpiphanyReorientAction;
use codex_app_server_protocol::ThreadEpiphanyReorientCheckpointStatus;
use codex_app_server_protocol::ThreadEpiphanyReorientDecision;
use codex_app_server_protocol::ThreadEpiphanyReorientReason;
use codex_app_server_protocol::ThreadEpiphanyReorientSource;
use codex_app_server_protocol::ThreadEpiphanyReorientStateStatus;
use codex_app_server_protocol::ThreadEpiphanyReorientWorkerLaunchDocument;
use codex_app_server_protocol::ThreadEpiphanyRetrievalFreshness;
use codex_app_server_protocol::ThreadEpiphanyRetrievalFreshnessStatus;
use codex_app_server_protocol::ThreadEpiphanyRoleWorkerLaunchDocument;
use codex_app_server_protocol::ThreadEpiphanyUpdatePatch;
use codex_app_server_protocol::ThreadEpiphanyViewLens;
use codex_app_server_protocol::ThreadEpiphanyWorkerLaunchDocument;
use epiphany_core::EpiphanyContextParams;
use epiphany_core::EpiphanyDistillInput;
use epiphany_core::EpiphanyGraphQuery;
use epiphany_core::EpiphanyGraphQueryDirection;
use epiphany_core::EpiphanyGraphQueryKind;
use epiphany_core::EpiphanyReorientWorkerLaunchDocument;
use epiphany_core::EpiphanyRoleStatePatchDocument;
use epiphany_core::EpiphanyRoleWorkerLaunchDocument;
use epiphany_core::EpiphanyViewLens;
use epiphany_core::EpiphanyWorkerLaunchDocument;
use epiphany_core::default_epiphany_view_lenses;
use epiphany_core::epiphany_view_needs_jobs;
use epiphany_core::epiphany_view_needs_pressure;
use epiphany_core::epiphany_view_needs_reorientation_inputs;
use epiphany_core::epiphany_view_needs_runtime_store;

pub fn default_core_epiphany_view_lenses() -> Vec<EpiphanyViewLens> {
    default_epiphany_view_lenses()
}

pub fn protocol_view_lenses_to_core(lenses: Vec<ThreadEpiphanyViewLens>) -> Vec<EpiphanyViewLens> {
    lenses.into_iter().map(protocol_view_lens_to_core).collect()
}

pub fn core_epiphany_view_needs_jobs(lenses: &[EpiphanyViewLens]) -> bool {
    epiphany_view_needs_jobs(lenses)
}

pub fn core_epiphany_view_needs_reorientation_inputs(lenses: &[EpiphanyViewLens]) -> bool {
    epiphany_view_needs_reorientation_inputs(lenses)
}

pub fn core_epiphany_view_needs_pressure(lenses: &[EpiphanyViewLens]) -> bool {
    epiphany_view_needs_pressure(lenses)
}

pub fn core_epiphany_view_needs_runtime_store(lenses: &[EpiphanyViewLens]) -> bool {
    epiphany_view_needs_runtime_store(lenses)
}

pub fn protocol_context_params_to_core(
    params: &ThreadEpiphanyContextParams,
) -> EpiphanyContextParams {
    EpiphanyContextParams {
        graph_node_ids: params.graph_node_ids.clone(),
        graph_edge_ids: params.graph_edge_ids.clone(),
        observation_ids: params.observation_ids.clone(),
        evidence_ids: params.evidence_ids.clone(),
        include_active_frontier: params.include_active_frontier,
        include_linked_evidence: params.include_linked_evidence,
    }
}

pub fn protocol_distill_params_to_core(
    params: ThreadEpiphanyDistillParams,
) -> EpiphanyDistillInput {
    let ThreadEpiphanyDistillParams {
        source_kind,
        status,
        text,
        subject,
        evidence_kind,
        code_refs,
        ..
    } = params;
    EpiphanyDistillInput {
        source_kind,
        status,
        text,
        subject,
        evidence_kind,
        code_refs,
    }
}

pub fn protocol_graph_query_to_core(query: &ThreadEpiphanyGraphQuery) -> EpiphanyGraphQuery {
    EpiphanyGraphQuery {
        kind: protocol_graph_query_kind_to_core(query.kind),
        node_ids: query.node_ids.clone(),
        edge_ids: query.edge_ids.clone(),
        paths: query.paths.clone(),
        symbols: query.symbols.clone(),
        edge_kinds: query.edge_kinds.clone(),
        direction: query.direction.map(protocol_graph_query_direction_to_core),
        depth: query.depth,
        include_links: query.include_links,
    }
}

pub fn protocol_worker_launch_document_to_core(
    document: ThreadEpiphanyWorkerLaunchDocument,
) -> EpiphanyWorkerLaunchDocument {
    match document {
        ThreadEpiphanyWorkerLaunchDocument::Role(document) => EpiphanyWorkerLaunchDocument::Role(
            protocol_role_worker_launch_document_to_core(document),
        ),
        ThreadEpiphanyWorkerLaunchDocument::Reorient(document) => {
            EpiphanyWorkerLaunchDocument::Reorient(
                protocol_reorient_worker_launch_document_to_core(document),
            )
        }
    }
}

pub fn protocol_update_patch_to_core(
    patch: &ThreadEpiphanyUpdatePatch,
) -> EpiphanyRoleStatePatchDocument {
    EpiphanyRoleStatePatchDocument {
        objective: patch.objective.clone(),
        active_subgoal_id: patch.active_subgoal_id.clone(),
        subgoals: patch.subgoals.clone(),
        invariants: patch.invariants.clone(),
        graphs: patch.graphs.clone(),
        graph_frontier: patch.graph_frontier.clone(),
        graph_checkpoint: patch.graph_checkpoint.clone(),
        scratch: patch.scratch.clone(),
        investigation_checkpoint: patch.investigation_checkpoint.clone(),
        job_bindings: patch.job_bindings.clone(),
        acceptance_receipts: patch.acceptance_receipts.clone(),
        runtime_links: patch.runtime_links.clone(),
        observations: patch.observations.clone(),
        evidence: patch.evidence.clone(),
        churn: patch.churn.clone(),
        mode: patch.mode.clone(),
        planning: patch.planning.clone(),
    }
}

pub fn protocol_freshness_response_from_surface(
    surface: EpiphanyFreshnessSurface,
) -> ThreadEpiphanyFreshnessResponse {
    ThreadEpiphanyFreshnessResponse {
        thread_id: surface.thread_id,
        source: match surface.source {
            EpiphanySurfaceSource::Stored => ThreadEpiphanyFreshnessSource::Stored,
            EpiphanySurfaceSource::Live => ThreadEpiphanyFreshnessSource::Live,
        },
        state_revision: surface.state_revision,
        retrieval: ThreadEpiphanyRetrievalFreshness {
            status: match surface.retrieval.status {
                EpiphanyRetrievalFreshnessStatus::Missing => {
                    ThreadEpiphanyRetrievalFreshnessStatus::Missing
                }
                EpiphanyRetrievalFreshnessStatus::Ready => {
                    ThreadEpiphanyRetrievalFreshnessStatus::Ready
                }
                EpiphanyRetrievalFreshnessStatus::Stale => {
                    ThreadEpiphanyRetrievalFreshnessStatus::Stale
                }
                EpiphanyRetrievalFreshnessStatus::Indexing => {
                    ThreadEpiphanyRetrievalFreshnessStatus::Indexing
                }
                EpiphanyRetrievalFreshnessStatus::Unavailable => {
                    ThreadEpiphanyRetrievalFreshnessStatus::Unavailable
                }
            },
            semantic_available: surface.retrieval.semantic_available,
            last_indexed_at_unix_seconds: surface.retrieval.last_indexed_at_unix_seconds,
            indexed_file_count: surface.retrieval.indexed_file_count,
            indexed_chunk_count: surface.retrieval.indexed_chunk_count,
            dirty_paths: surface.retrieval.dirty_paths,
            note: surface.retrieval.note,
        },
        graph: ThreadEpiphanyGraphFreshness {
            status: match surface.graph.status {
                EpiphanyGraphFreshnessStatus::Missing => {
                    ThreadEpiphanyGraphFreshnessStatus::Missing
                }
                EpiphanyGraphFreshnessStatus::Ready => ThreadEpiphanyGraphFreshnessStatus::Ready,
                EpiphanyGraphFreshnessStatus::Stale => ThreadEpiphanyGraphFreshnessStatus::Stale,
            },
            graph_freshness: surface.graph.graph_freshness,
            checkpoint_id: surface.graph.checkpoint_id,
            dirty_path_count: surface.graph.dirty_path_count,
            dirty_paths: surface.graph.dirty_paths,
            open_question_count: surface.graph.open_question_count,
            open_gap_count: surface.graph.open_gap_count,
            note: surface.graph.note,
        },
        watcher: ThreadEpiphanyInvalidationInput {
            status: match surface.watcher.status {
                EpiphanyInvalidationStatus::Unavailable => {
                    ThreadEpiphanyInvalidationStatus::Unavailable
                }
                EpiphanyInvalidationStatus::Clean => ThreadEpiphanyInvalidationStatus::Clean,
                EpiphanyInvalidationStatus::Changed => ThreadEpiphanyInvalidationStatus::Changed,
            },
            watched_root: surface.watcher.watched_root,
            observed_at_unix_seconds: surface.watcher.observed_at_unix_seconds,
            changed_path_count: surface.watcher.changed_path_count,
            changed_paths: surface.watcher.changed_paths,
            graph_node_ids: surface.watcher.graph_node_ids,
            active_frontier_node_ids: surface.watcher.active_frontier_node_ids,
            note: surface.watcher.note,
        },
    }
}

pub fn protocol_job_from_surface(
    job: EpiphanyJobView,
    launcher_job_id: Option<String>,
    backend_job_id_override: Option<String>,
) -> ThreadEpiphanyJob {
    ThreadEpiphanyJob {
        id: job.id,
        kind: match job.kind {
            EpiphanyJobKind::Indexing => ThreadEpiphanyJobKind::Indexing,
            EpiphanyJobKind::Remap => ThreadEpiphanyJobKind::Remap,
            EpiphanyJobKind::Verification => ThreadEpiphanyJobKind::Verification,
            EpiphanyJobKind::Specialist => ThreadEpiphanyJobKind::Specialist,
        },
        scope: job.scope,
        owner_role: job.owner_role,
        launcher_job_id,
        authority_scope: job.authority_scope,
        backend_job_id: backend_job_id_override.or(job.runtime_job_id),
        status: match job.status {
            EpiphanyJobStatus::Idle => ThreadEpiphanyJobStatus::Idle,
            EpiphanyJobStatus::Needed => ThreadEpiphanyJobStatus::Needed,
            EpiphanyJobStatus::Pending => ThreadEpiphanyJobStatus::Pending,
            EpiphanyJobStatus::Running => ThreadEpiphanyJobStatus::Running,
            EpiphanyJobStatus::Completed => ThreadEpiphanyJobStatus::Completed,
            EpiphanyJobStatus::Failed => ThreadEpiphanyJobStatus::Failed,
            EpiphanyJobStatus::Cancelled => ThreadEpiphanyJobStatus::Cancelled,
            EpiphanyJobStatus::Blocked => ThreadEpiphanyJobStatus::Blocked,
            EpiphanyJobStatus::Unavailable => ThreadEpiphanyJobStatus::Unavailable,
        },
        items_processed: job.items_processed,
        items_total: job.items_total,
        progress_note: job.progress_note,
        last_checkpoint_at_unix_seconds: job.last_checkpoint_at_unix_seconds,
        blocking_reason: job.blocking_reason,
        active_thread_ids: job.active_thread_ids,
        linked_subgoal_ids: job.linked_subgoal_ids,
        linked_graph_node_ids: job.linked_graph_node_ids,
    }
}

pub fn protocol_reorient_state_status(
    status: EpiphanyReorientStateStatus,
) -> ThreadEpiphanyReorientStateStatus {
    match status {
        EpiphanyReorientStateStatus::Missing => ThreadEpiphanyReorientStateStatus::Missing,
        EpiphanyReorientStateStatus::Ready => ThreadEpiphanyReorientStateStatus::Ready,
    }
}

pub fn protocol_reorient_source(source: EpiphanySurfaceSource) -> ThreadEpiphanyReorientSource {
    match source {
        EpiphanySurfaceSource::Stored => ThreadEpiphanyReorientSource::Stored,
        EpiphanySurfaceSource::Live => ThreadEpiphanyReorientSource::Live,
    }
}

pub fn protocol_reorient_decision(
    decision: EpiphanyReorientDecision,
) -> ThreadEpiphanyReorientDecision {
    ThreadEpiphanyReorientDecision {
        action: match decision.action {
            EpiphanyReorientAction::Resume => ThreadEpiphanyReorientAction::Resume,
            EpiphanyReorientAction::Regather => ThreadEpiphanyReorientAction::Regather,
        },
        checkpoint_status: match decision.checkpoint_status {
            EpiphanyReorientCheckpointStatus::Missing => {
                ThreadEpiphanyReorientCheckpointStatus::Missing
            }
            EpiphanyReorientCheckpointStatus::ResumeReady => {
                ThreadEpiphanyReorientCheckpointStatus::ResumeReady
            }
            EpiphanyReorientCheckpointStatus::RegatherRequired => {
                ThreadEpiphanyReorientCheckpointStatus::RegatherRequired
            }
        },
        checkpoint_id: decision.checkpoint_id,
        pressure_level: match decision.pressure_level {
            EpiphanyReorientPressureLevel::Unknown => ThreadEpiphanyPressureLevel::Unknown,
            EpiphanyReorientPressureLevel::Low => ThreadEpiphanyPressureLevel::Low,
            EpiphanyReorientPressureLevel::Medium => ThreadEpiphanyPressureLevel::Elevated,
            EpiphanyReorientPressureLevel::High => ThreadEpiphanyPressureLevel::High,
            EpiphanyReorientPressureLevel::Critical => ThreadEpiphanyPressureLevel::Critical,
        },
        retrieval_status: protocol_reorient_retrieval_status(decision.retrieval_status),
        graph_status: protocol_reorient_graph_status(decision.graph_status),
        watcher_status: protocol_reorient_watcher_status(decision.watcher_status),
        reasons: decision
            .reasons
            .into_iter()
            .map(protocol_reorient_reason)
            .collect(),
        checkpoint_dirty_paths: decision.checkpoint_dirty_paths,
        checkpoint_changed_paths: decision.checkpoint_changed_paths,
        active_frontier_node_ids: decision.active_frontier_node_ids,
        next_action: decision.next_action,
        note: decision.note,
    }
}

fn protocol_view_lens_to_core(lens: ThreadEpiphanyViewLens) -> EpiphanyViewLens {
    match lens {
        ThreadEpiphanyViewLens::Scene => EpiphanyViewLens::Scene,
        ThreadEpiphanyViewLens::Jobs => EpiphanyViewLens::Jobs,
        ThreadEpiphanyViewLens::Roles => EpiphanyViewLens::Roles,
        ThreadEpiphanyViewLens::Planning => EpiphanyViewLens::Planning,
        ThreadEpiphanyViewLens::Pressure => EpiphanyViewLens::Pressure,
        ThreadEpiphanyViewLens::Reorient => EpiphanyViewLens::Reorient,
        ThreadEpiphanyViewLens::Crrc => EpiphanyViewLens::Crrc,
        ThreadEpiphanyViewLens::Coordinator => EpiphanyViewLens::Coordinator,
    }
}

fn protocol_graph_query_kind_to_core(kind: ThreadEpiphanyGraphQueryKind) -> EpiphanyGraphQueryKind {
    match kind {
        ThreadEpiphanyGraphQueryKind::Node => EpiphanyGraphQueryKind::Node,
        ThreadEpiphanyGraphQueryKind::Path => EpiphanyGraphQueryKind::Path,
        ThreadEpiphanyGraphQueryKind::FrontierNeighborhood => {
            EpiphanyGraphQueryKind::FrontierNeighborhood
        }
        ThreadEpiphanyGraphQueryKind::Neighbors => EpiphanyGraphQueryKind::Neighbors,
    }
}

fn protocol_graph_query_direction_to_core(
    direction: ThreadEpiphanyGraphQueryDirection,
) -> EpiphanyGraphQueryDirection {
    match direction {
        ThreadEpiphanyGraphQueryDirection::Incoming => EpiphanyGraphQueryDirection::Incoming,
        ThreadEpiphanyGraphQueryDirection::Outgoing => EpiphanyGraphQueryDirection::Outgoing,
        ThreadEpiphanyGraphQueryDirection::Both => EpiphanyGraphQueryDirection::Both,
    }
}

fn protocol_role_worker_launch_document_to_core(
    document: ThreadEpiphanyRoleWorkerLaunchDocument,
) -> EpiphanyRoleWorkerLaunchDocument {
    EpiphanyRoleWorkerLaunchDocument {
        thread_id: document.thread_id,
        role_id: document.role_id,
        state_revision: document.state_revision,
        objective: document.objective,
        active_subgoal_id: document.active_subgoal_id,
        active_subgoals: document.active_subgoals,
        active_graph_node_ids: document.active_graph_node_ids,
        investigation_checkpoint: document.investigation_checkpoint,
        scratch: document.scratch,
        invariants: document.invariants,
        graphs: document.graphs,
        recent_evidence: document.recent_evidence,
        recent_observations: document.recent_observations,
        graph_frontier: document.graph_frontier,
        graph_checkpoint: document.graph_checkpoint,
        planning: document.planning,
        churn: document.churn,
    }
}

fn protocol_reorient_worker_launch_document_to_core(
    document: ThreadEpiphanyReorientWorkerLaunchDocument,
) -> EpiphanyReorientWorkerLaunchDocument {
    EpiphanyReorientWorkerLaunchDocument {
        thread_id: document.thread_id,
        mode: document.mode,
        checkpoint_id: document.checkpoint_id,
        checkpoint_kind: document.checkpoint_kind,
        checkpoint_disposition: document.checkpoint_disposition,
        checkpoint_focus: document.checkpoint_focus,
        checkpoint_summary: document.checkpoint_summary,
        checkpoint_next_action: document.checkpoint_next_action,
        checkpoint_open_questions: document.checkpoint_open_questions,
        checkpoint_evidence_ids: document.checkpoint_evidence_ids,
        checkpoint_code_refs: document.checkpoint_code_refs,
        decision_reasons: document.decision_reasons,
        decision_note: document.decision_note,
        pressure_level: document.pressure_level,
        retrieval_status: document.retrieval_status,
        graph_status: document.graph_status,
        watcher_status: document.watcher_status,
        checkpoint_dirty_paths: document.checkpoint_dirty_paths,
        checkpoint_changed_paths: document.checkpoint_changed_paths,
        scratch: document.scratch,
        graphs: document.graphs,
        recent_evidence: document.recent_evidence,
        recent_observations: document.recent_observations,
        active_frontier_node_ids: document.active_frontier_node_ids,
        linked_subgoal_ids: document.linked_subgoal_ids,
        linked_graph_node_ids: document.linked_graph_node_ids,
    }
}

fn protocol_reorient_retrieval_status(
    status: EpiphanyReorientFreshnessStatus,
) -> ThreadEpiphanyRetrievalFreshnessStatus {
    match status {
        EpiphanyReorientFreshnessStatus::Unknown => ThreadEpiphanyRetrievalFreshnessStatus::Missing,
        EpiphanyReorientFreshnessStatus::Clean => ThreadEpiphanyRetrievalFreshnessStatus::Ready,
        EpiphanyReorientFreshnessStatus::Dirty => ThreadEpiphanyRetrievalFreshnessStatus::Indexing,
        EpiphanyReorientFreshnessStatus::Stale | EpiphanyReorientFreshnessStatus::Changed => {
            ThreadEpiphanyRetrievalFreshnessStatus::Stale
        }
    }
}

fn protocol_reorient_graph_status(
    status: EpiphanyReorientFreshnessStatus,
) -> ThreadEpiphanyGraphFreshnessStatus {
    match status {
        EpiphanyReorientFreshnessStatus::Unknown => ThreadEpiphanyGraphFreshnessStatus::Missing,
        EpiphanyReorientFreshnessStatus::Clean => ThreadEpiphanyGraphFreshnessStatus::Ready,
        EpiphanyReorientFreshnessStatus::Dirty
        | EpiphanyReorientFreshnessStatus::Stale
        | EpiphanyReorientFreshnessStatus::Changed => ThreadEpiphanyGraphFreshnessStatus::Stale,
    }
}

fn protocol_reorient_watcher_status(
    status: EpiphanyReorientFreshnessStatus,
) -> ThreadEpiphanyInvalidationStatus {
    match status {
        EpiphanyReorientFreshnessStatus::Unknown => ThreadEpiphanyInvalidationStatus::Unavailable,
        EpiphanyReorientFreshnessStatus::Clean => ThreadEpiphanyInvalidationStatus::Clean,
        EpiphanyReorientFreshnessStatus::Dirty
        | EpiphanyReorientFreshnessStatus::Stale
        | EpiphanyReorientFreshnessStatus::Changed => ThreadEpiphanyInvalidationStatus::Changed,
    }
}

fn protocol_reorient_reason(reason: EpiphanyReorientReason) -> ThreadEpiphanyReorientReason {
    match reason {
        EpiphanyReorientReason::MissingState => ThreadEpiphanyReorientReason::MissingState,
        EpiphanyReorientReason::MissingCheckpoint => {
            ThreadEpiphanyReorientReason::MissingCheckpoint
        }
        EpiphanyReorientReason::CheckpointReady => ThreadEpiphanyReorientReason::CheckpointReady,
        EpiphanyReorientReason::CheckpointRequestedRegather => {
            ThreadEpiphanyReorientReason::CheckpointRequestedRegather
        }
        EpiphanyReorientReason::CheckpointPathsDirty => {
            ThreadEpiphanyReorientReason::CheckpointPathsDirty
        }
        EpiphanyReorientReason::CheckpointPathsChanged => {
            ThreadEpiphanyReorientReason::CheckpointPathsChanged
        }
        EpiphanyReorientReason::FrontierChanged => ThreadEpiphanyReorientReason::FrontierChanged,
        EpiphanyReorientReason::UnanchoredCheckpointWhileStateStale => {
            ThreadEpiphanyReorientReason::UnanchoredCheckpointWhileStateStale
        }
    }
}