//! Standalone research caller of the unchanged public exact reader.
use fettl::local_context::LocalContext;
use local_persistence::{LocalStore, RootIdentity, StoreOptions};
use serde_json::{Value, json};
use std::sync::{Arc, atomic::AtomicBool};
use std::time::{Duration, Instant};
use trellis_core::{
    entity::*,
    storage::*,
    wire::{DataClassTag, IdentityRef, RevisionRef as WireRevision, VisibilityTag},
};
use trellis_engine::query::ReadDeadline;
use trellis_store::{TrellisStore, read::TrellisReader};
struct Grant(GraphScope);
impl ReadAuthorization for Grant {
    fn authorize_scope(&self, _: &IdentityRef, scope: &GraphScope) -> Result<(), ReadError> {
        if scope == &self.0 {
            Ok(())
        } else {
            Err(ReadError::Unauthorized)
        }
    }
    fn authorize(
        &self,
        principal: &IdentityRef,
        resource: ReadResource<'_>,
    ) -> Result<(), ReadError> {
        let scope = match resource {
            ReadResource::Entity(v) => v.scope(),
            ReadResource::Declaration(v) => &v.scope,
            ReadResource::Relationship(v) => &v.scope,
            ReadResource::Document(v) => &v.scope,
            ReadResource::Text(v) => &v.scope,
            ReadResource::Annotation(v) => &v.scope,
            ReadResource::DeclarationBinding(v) => &v.scope,
            ReadResource::Edge { owner, .. } | ReadResource::Evidence { owner, .. } => {
                owner.scope()
            }
        };
        self.authorize_scope(principal, scope)
    }
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
    let path = std::env::args()
        .nth(1)
        .ok_or("expected options JSON path")?;
    let input: Value = serde_json::from_slice(&std::fs::read(path)?)?;
    observe(input)
}
fn observe(input: Value) -> Result<(), Box<dyn std::error::Error>> {
    let cancelled = AtomicBool::new(false);
    let seconds = input["deadline_seconds"]
        .as_u64()
        .ok_or("deadline_seconds")?;
    let deadline = Instant::now()
        .checked_add(Duration::from_secs(seconds))
        .ok_or("deadline overflow")?;
    let control = ReadDeadline::new(deadline, &cancelled);
    let scope: GraphScope = serde_json::from_value(input["scope"].clone())?;
    let mut options = StoreOptions::new(
        input["state"].as_str().ok_or("state")?.into(),
        RootIdentity::new("research-1316".into(), "research-1316".into(), 1)?,
    );
    options.namespaces = LocalContext::required_namespaces()?;
    let owner = Arc::new(LocalStore::open_existing(&options)?);
    let before = owner
        .read_page(trellis_store::TRELLIS_NAMESPACE, "", None, 1)?
        .store_revision;
    let store = Arc::new(TrellisStore::new(
        owner.clone(),
        WireRevision::new("research.host", "observer")?,
    ));
    let reader = TrellisReader::new(
        store,
        IdentityRef::new("research.principal", "local")?,
        Arc::new(Grant(scope.clone())),
    );
    let revision = reader.revision(&scope, &control)?;
    let mut query = ExactQuery {
        schema_version: EXACT_QUERY_SCHEMA_VERSION,
        max_bytes: MAX_QUERY_FRAME_BYTES as u32,
        max_examined: MAX_EXAMINED_RECORDS as u16,
        filter: ExactFilter {
            visibility: VisibilityTag::LocalOnly,
            data_class: DataClassTag::GraphFacts,
            include_stale: true,
        },
        scope,
        expected_graph_revision: revision.graph_revision.clone(),
        expected_source_revision: revision.source_revision.clone(),
        selector: ExactSelector::Kind {
            kinds: vec![
                CanonicalKind::Entity(CanonicalEntityKind::Concept),
                CanonicalKind::Entity(CanonicalEntityKind::StructShape),
            ],
        },
        cursor: None,
        limit: MAX_EXACT_ITEMS,
    };
    let mut observations = Vec::new();
    for node in input["nodes"].as_array().ok_or("nodes")? {
        let key = DeclarationKey::new(node["key"].as_str().ok_or("key")?)?;
        let kind: CanonicalEntityKind = serde_json::from_value(node["kind"].clone())?;
        query.selector = ExactSelector::Entity {
            id: declaration_entity_id(&query.scope, kind, &key)?,
            version: None,
        };
        query.cursor = None;
        let entity_page = reader.exact(&query, &control)?;
        let entity = match entity_page.items.first() {
            Some(QueryItem::Entity(entity)) => entity,
            _ => return Err("missing exact canonical entity".into()),
        };
        let anchor = CanonicalRef::Entity {
            id: entity.metadata().id().clone(),
            version: entity.metadata().version(),
        };
        let mut adjacency = Vec::new();
        for direction in [RelationDirection::Outgoing, RelationDirection::Incoming] {
            query.selector = ExactSelector::Adjacency {
                anchor: anchor.clone(),
                kinds: Vec::new(),
                direction,
            };
            query.cursor = None;
            loop {
                let page = reader.exact(&query, &control)?;
                query.cursor = page.next_cursor.clone();
                adjacency.push(json!({"direction": direction, "page": page}));
                if query.cursor.is_none() {
                    break;
                }
            }
        }
        observations.push(json!({"key": key, "entity": entity_page, "adjacency": adjacency}));
    }
    let after = owner
        .read_page(trellis_store::TRELLIS_NAMESPACE, "", None, 1)?
        .store_revision;
    println!(
        "{}",
        json!({"revision": revision, "nodes": observations, "before": before, "after": after})
    );
    Ok(())
}
