mod app;
mod error;
mod rdf;
mod windows;
mod widget;
mod navigator;
mod theme;
mod args;

use clap::Parser;
use iced::futures::StreamExt;
use ldp::middleware::BasicAuthMiddleware;
use ldp::reqwest::{Client, Url};
use ldp::reqwest_middleware::ClientBuilder;
use ldp::traverse::Traverse;
use tracing::{debug, debug_span, error, field};
use crate::app::Publisher;
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::util::SubscriberInitExt;
use tracing_subscriber::{EnvFilter, fmt};
use tracing_subscriber::fmt::format::FmtSpan;
use gl_search::{Document, Schema, SearchIndex};
use crate::args::{AppArgs, Command};
use crate::rdf::ontology::Ontology;

fn main() -> color_eyre::Result<()> {
    let appender = tracing_appender::rolling::never("/tmp", "publisher-log");
    tracing_subscriber::registry()
        .with(fmt::layer().with_span_events(FmtSpan::CLOSE).with_writer(appender))
        .with(EnvFilter::from_default_env())
        .init();
    color_eyre::install()?;

    let ontology = Ontology::builder()
        .with_path("/home/alex/.local/share/org.graphofliberty.desktop/ontology")
        .build()
        .expect("Failed to build ontology");

    let mut index = SearchIndex::builder()
        .with_path("/home/alex/.local/share/org.graphofliberty.desktop/index")
        .build()
        .expect("Failed to build search index");

    let args = AppArgs::parse();
    match args.command {
        Some(Command::Search(args)) => {
            for doc in index.query(args.discriminant, &args.query, Schema::all_fields(), 500000)? {
                println!("{}", doc.to_json(Schema::schema()));
            }
        }
        Some(Command::Reindex) => {
            let mut writer = index.writer()?;
            debug_span!("Clear Index").in_scope(|| {
                writer.delete_all_documents()?;
                writer.commit()
            })?;

            {
                let span = debug_span!("Index Schema", documents = field::Empty).entered();
                let store = ontology.store();
                let count = gl_search::rdf::index_schema(store, &*gl_search::language::ENGLISH_OR_UNTAGGED, &writer)?;
                span.record("documents", count);
            }

            let starting_url = Url::parse("http://fedora.quill.lan/rest/")?;
            let runtime = tokio::runtime::Builder::new_multi_thread()
                .enable_all()
                .name("repository-traversal")
                .build()?;

            let traversal_task = runtime.spawn(async move {
                let http_client = ClientBuilder::new(Client::new())
                    .with(BasicAuthMiddleware::new(
                        "fedoraAdmin".to_string(),
                        Some("fedoraAdmin".to_string()),
                    ))
                    .build();

                let mut documents = 0usize;
                let mut traversal = Traverse::new(http_client, starting_url, None);
                while let Some(result) = traversal.next().await {
                    match result {
                        Ok(rdf_source) => {
                            documents += gl_search::rdf::index_entity(rdf_source.dataset(), &*gl_search::language::ENGLISH_OR_UNTAGGED, &writer)?;
                        }
                        Err(err) => error!(?err),
                    }
                }
                debug!(documents, "Repository Traversal");
                Ok::<_, gl_search::SearchError>(writer)
            });

            let mut writer = runtime.block_on(traversal_task)??;
            debug_span!("Commit").in_scope(|| {
                writer.commit()
            })?;
        }
        None => {
            iced::daemon(Publisher::new, Publisher::update, Publisher::view)
                .title(Publisher::title)
                .subscription(Publisher::subscription)
                .run()?;
        }
    }

    Ok(())
}