use crate::{client_server, utils, ConduitResult, Database, Error, PduEvent, Result, Ruma};
use get_profile_information::v1::ProfileField;
use http::header::{HeaderValue, AUTHORIZATION, HOST};
use log::{error, warn};
use rocket::{get, post, put, response::content::Json, State};
use ruma::{
    api::{
        federation::{
            directory::{get_public_rooms, get_public_rooms_filtered},
            discovery::{
                get_server_keys, get_server_version::v1 as get_server_version, ServerSigningKeys,
                VerifyKey,
            },
            event::get_missing_events,
            query::get_profile_information,
            transactions::send_transaction_message,
        },
        OutgoingRequest,
    },
    directory::{IncomingFilter, IncomingRoomNetwork},
    EventId, RoomId, RoomVersionId, ServerName, ServerSigningKeyId, UserId,
};
use std::{
    collections::{BTreeMap, BTreeSet},
    convert::TryFrom,
    fmt::Debug,
    sync::Arc,
    time::{Duration, SystemTime},
};
use trust_dns_resolver::AsyncResolver;

pub async fn request_well_known(
    globals: &crate::database::globals::Globals,
    destination: &str,
) -> Option<String> {
    let body: serde_json::Value = serde_json::from_str(
        &globals
            .reqwest_client()
            .get(&format!(
                "https://{}/.well-known/matrix/server",
                destination
            ))
            .send()
            .await
            .ok()?
            .text()
            .await
            .ok()?,
    )
    .ok()?;
    Some(body.get("m.server")?.as_str()?.to_owned())
}

pub async fn send_request<T: OutgoingRequest>(
    globals: &crate::database::globals::Globals,
    destination: Box<ServerName>,
    request: T,
) -> Result<T::IncomingResponse>
where
    T: Debug,
{
    if !globals.federation_enabled() {
        return Err(Error::bad_config("Federation is disabled."));
    }

    let resolver = AsyncResolver::tokio_from_system_conf().await.map_err(|_| {
        Error::bad_config("Failed to set up trust dns resolver with system config.")
    })?;

    let mut host = None;

    let actual_destination = "https://".to_owned()
        + &if let Some(mut delegated_hostname) =
            request_well_known(globals, &destination.as_str()).await
        {
            if let Ok(Some(srv)) = resolver
                .srv_lookup(format!("_matrix._tcp.{}", delegated_hostname))
                .await
                .map(|srv| srv.iter().next().map(|result| result.target().to_string()))
            {
                host = Some(delegated_hostname);
                srv.trim_end_matches('.').to_owned()
            } else {
                if delegated_hostname.find(':').is_none() {
                    delegated_hostname += ":8448";
                }
                delegated_hostname
            }
        } else {
            let mut destination = destination.as_str().to_owned();
            if destination.find(':').is_none() {
                destination += ":8448";
            }
            destination
        };

    let mut http_request = request
        .try_into_http_request(&actual_destination, Some(""))
        .map_err(|e| {
            warn!("Failed to find destination {}: {}", actual_destination, e);
            Error::BadServerResponse("Invalid destination")
        })?;

    let mut request_map = serde_json::Map::new();

    if !http_request.body().is_empty() {
        request_map.insert(
            "content".to_owned(),
            serde_json::from_slice(http_request.body())
                .expect("body is valid json, we just created it"),
        );
    };

    request_map.insert("method".to_owned(), T::METADATA.method.to_string().into());
    request_map.insert(
        "uri".to_owned(),
        http_request
            .uri()
            .path_and_query()
            .expect("all requests have a path")
            .to_string()
            .into(),
    );
    request_map.insert("origin".to_owned(), globals.server_name().as_str().into());
    request_map.insert("destination".to_owned(), destination.as_str().into());

    let mut request_json =
        serde_json::from_value(request_map.into()).expect("valid JSON is valid BTreeMap");

    ruma::signatures::sign_json(
        globals.server_name().as_str(),
        globals.keypair(),
        &mut request_json,
    )
    .expect("our request json is what ruma expects");

    let request_json: serde_json::Map<String, serde_json::Value> =
        serde_json::from_slice(&serde_json::to_vec(&request_json).unwrap()).unwrap();

    let signatures = request_json["signatures"]
        .as_object()
        .unwrap()
        .values()
        .map(|v| {
            v.as_object()
                .unwrap()
                .iter()
                .map(|(k, v)| (k, v.as_str().unwrap()))
        });

    for signature_server in signatures {
        for s in signature_server {
            http_request.headers_mut().insert(
                AUTHORIZATION,
                HeaderValue::from_str(&format!(
                    "X-Matrix origin={},key=\"{}\",sig=\"{}\"",
                    globals.server_name(),
                    s.0,
                    s.1
                ))
                .unwrap(),
            );
        }
    }

    if let Some(host) = host {
        http_request
            .headers_mut()
            .insert(HOST, HeaderValue::from_str(&host).unwrap());
    }

    let mut reqwest_request = reqwest::Request::try_from(http_request)
        .expect("all http requests are valid reqwest requests");

    *reqwest_request.timeout_mut() = Some(Duration::from_secs(30));

    let url = reqwest_request.url().clone();
    let reqwest_response = globals.reqwest_client().execute(reqwest_request).await;

    // Because reqwest::Response -> http::Response is complicated:
    match reqwest_response {
        Ok(mut reqwest_response) => {
            let status = reqwest_response.status();
            let mut http_response = http::Response::builder().status(status);
            let headers = http_response.headers_mut().unwrap();

            for (k, v) in reqwest_response.headers_mut().drain() {
                if let Some(key) = k {
                    headers.insert(key, v);
                }
            }

            let status = reqwest_response.status();

            let body = reqwest_response
                .bytes()
                .await
                .unwrap_or_else(|e| {
                    warn!("server error: {}", e);
                    Vec::new().into()
                }) // TODO: handle timeout
                .into_iter()
                .collect::<Vec<_>>();

            if status != 200 {
                warn!(
                    "Server returned bad response {} ({}): {} {:?}",
                    destination,
                    url,
                    status,
                    utils::string_from_bytes(&body)
                );
            }

            let response = T::IncomingResponse::try_from(
                http_response
                    .body(body)
                    .expect("reqwest body is valid http body"),
            );
            response.map_err(|_| {
                warn!(
                    "Server returned invalid response bytes {} ({})",
                    destination, url
                );
                Error::BadServerResponse("Server returned bad response.")
            })
        }
        Err(e) => Err(e.into()),
    }
}

#[cfg_attr(feature = "conduit_bin", get("/_matrix/federation/v1/version"))]
pub fn get_server_version_route(
    db: State<'_, Database>,
) -> ConduitResult<get_server_version::Response> {
    if !db.globals.federation_enabled() {
        return Err(Error::bad_config("Federation is disabled."));
    }

    Ok(get_server_version::Response {
        server: Some(get_server_version::Server {
            name: Some("Conduit".to_owned()),
            version: Some(env!("CARGO_PKG_VERSION").to_owned()),
        }),
    }
    .into())
}

#[cfg_attr(feature = "conduit_bin", get("/_matrix/key/v2/server"))]
pub fn get_server_keys_route(db: State<'_, Database>) -> Json<String> {
    if !db.globals.federation_enabled() {
        // TODO: Use proper types
        return Json("Federation is disabled.".to_owned());
    }

    let mut verify_keys = BTreeMap::new();
    verify_keys.insert(
        ServerSigningKeyId::try_from(
            format!("ed25519:{}", db.globals.keypair().version()).as_str(),
        )
        .expect("found invalid server signing keys in DB"),
        VerifyKey {
            key: base64::encode_config(db.globals.keypair().public_key(), base64::STANDARD_NO_PAD),
        },
    );
    let mut response = serde_json::from_slice(
        http::Response::try_from(get_server_keys::v2::Response {
            server_key: ServerSigningKeys {
                server_name: db.globals.server_name().to_owned(),
                verify_keys,
                old_verify_keys: BTreeMap::new(),
                signatures: BTreeMap::new(),
                valid_until_ts: SystemTime::now() + Duration::from_secs(60 * 2),
            },
        })
        .unwrap()
        .body(),
    )
    .unwrap();

    ruma::signatures::sign_json(
        db.globals.server_name().as_str(),
        db.globals.keypair(),
        &mut response,
    )
    .unwrap();

    Json(ruma::serde::to_canonical_json_string(&response).expect("JSON is canonical"))
}

#[cfg_attr(feature = "conduit_bin", get("/_matrix/key/v2/server/<_>"))]
pub fn get_server_keys_deprecated_route(db: State<'_, Database>) -> Json<String> {
    get_server_keys_route(db)
}

#[cfg_attr(
    feature = "conduit_bin",
    post("/_matrix/federation/v1/publicRooms", data = "<body>")
)]
pub async fn get_public_rooms_filtered_route(
    db: State<'_, Database>,
    body: Ruma<get_public_rooms_filtered::v1::Request<'_>>,
) -> ConduitResult<get_public_rooms_filtered::v1::Response> {
    if !db.globals.federation_enabled() {
        return Err(Error::bad_config("Federation is disabled."));
    }

    let response = client_server::get_public_rooms_filtered_helper(
        &db,
        None,
        body.limit,
        body.since.as_deref(),
        &body.filter,
        &body.room_network,
    )
    .await?
    .0;

    Ok(get_public_rooms_filtered::v1::Response {
        chunk: response
            .chunk
            .into_iter()
            .map(|c| {
                // Convert ruma::api::federation::directory::get_public_rooms::v1::PublicRoomsChunk
                // to ruma::api::client::r0::directory::PublicRoomsChunk
                Ok::<_, Error>(
                    serde_json::from_str(
                        &serde_json::to_string(&c)
                            .expect("PublicRoomsChunk::to_string always works"),
                    )
                    .expect("federation and client-server PublicRoomsChunk are the same type"),
                )
            })
            .filter_map(|r| r.ok())
            .collect(),
        prev_batch: response.prev_batch,
        next_batch: response.next_batch,
        total_room_count_estimate: response.total_room_count_estimate,
    }
    .into())
}

#[cfg_attr(
    feature = "conduit_bin",
    get("/_matrix/federation/v1/publicRooms", data = "<body>")
)]
pub async fn get_public_rooms_route(
    db: State<'_, Database>,
    body: Ruma<get_public_rooms::v1::Request<'_>>,
) -> ConduitResult<get_public_rooms::v1::Response> {
    if !db.globals.federation_enabled() {
        return Err(Error::bad_config("Federation is disabled."));
    }

    let response = client_server::get_public_rooms_filtered_helper(
        &db,
        None,
        body.limit,
        body.since.as_deref(),
        &IncomingFilter::default(),
        &IncomingRoomNetwork::Matrix,
    )
    .await?
    .0;

    Ok(get_public_rooms::v1::Response {
        chunk: response
            .chunk
            .into_iter()
            .map(|c| {
                // Convert ruma::api::federation::directory::get_public_rooms::v1::PublicRoomsChunk
                // to ruma::api::client::r0::directory::PublicRoomsChunk
                Ok::<_, Error>(
                    serde_json::from_str(
                        &serde_json::to_string(&c)
                            .expect("PublicRoomsChunk::to_string always works"),
                    )
                    .expect("federation and client-server PublicRoomsChunk are the same type"),
                )
            })
            .filter_map(|r| r.ok())
            .collect(),
        prev_batch: response.prev_batch,
        next_batch: response.next_batch,
        total_room_count_estimate: response.total_room_count_estimate,
    }
    .into())
}

#[derive(Clone, Debug, Ord, PartialOrd, Eq, PartialEq)]
pub enum PrevEvents<T> {
    Sequential(T),
    Fork(Vec<T>),
}

impl<T> IntoIterator for PrevEvents<T> {
    type Item = T;
    type IntoIter = std::vec::IntoIter<Self::Item>;

    fn into_iter(self) -> Self::IntoIter {
        match self {
            Self::Sequential(item) => vec![item].into_iter(),
            Self::Fork(list) => list.into_iter(),
        }
    }
}

impl<T: Clone> PrevEvents<T> {
    pub fn new(id: &[T]) -> Self {
        match id {
            [] => panic!("All events must have previous event"),
            [single_id] => Self::Sequential(single_id.clone()),
            rest => Self::Fork(rest.to_vec()),
        }
    }
}

#[cfg_attr(
    feature = "conduit_bin",
    put("/_matrix/federation/v1/send/<_>", data = "<body>")
)]
pub async fn send_transaction_message_route<'a>(
    db: State<'a, Database>,
    body: Ruma<send_transaction_message::v1::Request<'_>>,
) -> ConduitResult<send_transaction_message::v1::Response> {
    if !db.globals.federation_enabled() {
        return Err(Error::bad_config("Federation is disabled."));
    }

    for edu in &body.edus {
        match serde_json::from_str::<send_transaction_message::v1::Edu>(edu.json().get()) {
            Ok(edu) => match edu.edu_type.as_str() {
                "m.typing" => {
                    if let Some(typing) = edu.content.get("typing") {
                        if typing.as_bool().unwrap_or_default() {
                            db.rooms.edus.typing_add(
                                &UserId::try_from(edu.content["user_id"].as_str().unwrap())
                                    .unwrap(),
                                &RoomId::try_from(edu.content["room_id"].as_str().unwrap())
                                    .unwrap(),
                                3000 + utils::millis_since_unix_epoch(),
                                &db.globals,
                            )?;
                        } else {
                            db.rooms.edus.typing_remove(
                                &UserId::try_from(edu.content["user_id"].as_str().unwrap())
                                    .unwrap(),
                                &RoomId::try_from(edu.content["room_id"].as_str().unwrap())
                                    .unwrap(),
                                &db.globals,
                            )?;
                        }
                    }
                }
                "m.presence" => {}
                "m.receipt" => {}
                _ => {}
            },
            Err(_err) => {
                continue;
            }
        }
    }

    // TODO: For RoomVersion6 we must check that Raw<..> is canonical do we anywhere?
    // SPEC:
    // Servers MUST strictly enforce the JSON format specified in the appendices.
    // This translates to a 400 M_BAD_JSON error on most endpoints, or discarding of
    // events over federation. For example, the Federation API's /send endpoint would
    // discard the event whereas the Client Server API's /send/{eventType} endpoint
    // would return a M_BAD_JSON error.
    let mut resolved_map = BTreeMap::new();
    let mut pdu_idx = 0;
    // This is `for pdu in &body.pdus` but we need to do fancy continue/break so we need loop labels
    'outer: loop {
        if pdu_idx == body.pdus.len() {
            break 'outer;
        }
        let pdu = &body.pdus[pdu_idx];
        pdu_idx += 1;

        // Ruma/PduEvent/StateEvent satisfies - 1. Is a valid event, otherwise it is dropped.
        // state-res checks signatures - 2. Passes signature checks, otherwise event is dropped.
        // 3. Passes hash checks, otherwise it is redacted before being processed further.

        // TODO: redact event if hashing fails
        let (event_id, value) = crate::pdu::process_incoming_pdu(pdu);

        let mut pdu = serde_json::from_value::<PduEvent>(
            serde_json::to_value(&value).expect("CanonicalJsonObj is a valid JsonValue"),
        )
        .expect("all ruma pdus are conduit pdus");
        let room_id = &pdu.room_id;

        // If we have no idea about this room skip the PDU
        if !db.rooms.exists(room_id)? {
            resolved_map.insert(event_id, Err("Room is unknown to this server".into()));
            continue;
        }

        // The events that must be resolved to catch up to the incoming event
        let mut missing = vec![];
        let mut seen = state_res::StateMap::new();
        let mut seen_id = None;

        let mut prev_ids = vec![PrevEvents::new(&pdu.prev_events)];

        // This is `while let Some(event_id) = prev_ids.pop_front()` but with a fancy continue
        // in the case of a failed request to the server that sent the event
        'inner: loop {
            match prev_ids.pop() {
                Some(PrevEvents::Sequential(id)) => match db
                    .rooms
                    .pdu_state_hash(&db.rooms.get_pdu_id(&id)?.unwrap_or_default())?
                {
                    // We found a common ancestor
                    Some(state_hash) => {
                        seen_id = Some(id.clone());
                        seen = db.rooms.state_full(&state_hash)?;
                        if let Some(pdu) = db.rooms.get_pdu(&id)? {
                            if pdu.state_key.is_some() {
                                // This becomes the state after the common event
                                seen.insert(
                                    (pdu.kind.clone(), pdu.state_key.clone().unwrap()),
                                    pdu,
                                );
                            }
                        }
                        break 'inner;
                    }
                    // We need to fill in information about this event's `prev_events` (parents)
                    None => {
                        match send_request(
                            &db.globals,
                            body.body.origin.clone(),
                            ruma::api::federation::event::get_event::v1::Request::new(&id),
                        )
                        .await
                        {
                            Ok(res) => {
                                let (_, val) = crate::pdu::process_incoming_pdu(&res.pdu);
                                let prev_pdu = serde_json::from_value::<PduEvent>(
                                    serde_json::to_value(&val)
                                        .expect("CanonicalJsonObj is a valid JsonValue"),
                                )
                                .expect("all ruma pdus are conduit pdus");

                                // TODO: do we need this
                                assert_eq!(room_id, &prev_pdu.room_id);

                                prev_ids.push(PrevEvents::new(&prev_pdu.prev_events));
                                missing.push(PrevEvents::Sequential(prev_pdu));
                            }
                            // We can't hard fail because there are some valid errors, just
                            // keep checking PDU's
                            //
                            // As an example a possible error
                            // {"errcode":"M_FORBIDDEN","error":"Host not in room."}
                            Err(err) => {
                                resolved_map.insert(event_id, Err(err.to_string()));
                                // We have to give up on this PDU
                                continue 'outer;
                            }
                        };
                    }
                },
                Some(PrevEvents::Fork(ids)) => {
                    error!(
                        "prev_events > 1: {}",
                        serde_json::to_string_pretty(&pdu).unwrap()
                    );
                    // Don't kill our server with state-res
                    // TODO: set this at a reasonable level this is for debug/wip purposes
                    if ids.len() > 5 {
                        error!(
                            "prev_events > 1: {}",
                            serde_json::to_string_pretty(&pdu).unwrap()
                        );
                        resolved_map.insert(
                            event_id,
                            Err("Previous events are too large for state-res".into()),
                        );
                        continue 'outer;
                    }

                    // We want this to stay unique incase the fork comes together?
                    let mut prev_fork_ids = BTreeSet::new();
                    let mut missing_fork = vec![];
                    for id in &ids {
                        match db
                            .rooms
                            .pdu_state_hash(&db.rooms.get_pdu_id(&id)?.unwrap_or_default())?
                        {
                            // We found a common ancestor
                            Some(state_hash) => {
                                seen_id = Some(id.clone());
                                seen = db.rooms.state_full(&state_hash)?;
                                if let Some(pdu) = db.rooms.get_pdu(&id)? {
                                    if pdu.state_key.is_some() {
                                        // This becomes the state after the common event
                                        seen.insert(
                                            (pdu.kind.clone(), pdu.state_key.clone().unwrap()),
                                            pdu,
                                        );
                                    }
                                }
                                break 'inner;
                            }
                            None => match send_request(
                                &db.globals,
                                body.body.origin.clone(),
                                ruma::api::federation::event::get_event::v1::Request::new(&id),
                            )
                            .await
                            {
                                Ok(res) => {
                                    let (_, val) = crate::pdu::process_incoming_pdu(&res.pdu);
                                    let prev_pdu = serde_json::from_value::<PduEvent>(
                                        serde_json::to_value(&val)
                                            .expect("CanonicalJsonObj is a valid JsonValue"),
                                    )
                                    .expect("all ruma pdus are conduit pdus");

                                    // TODO: do we need this
                                    assert_eq!(room_id, &prev_pdu.room_id);

                                    for id in &prev_pdu.prev_events {
                                        prev_fork_ids.insert(id.clone());
                                    }
                                    missing_fork.push(prev_pdu);
                                }
                                // We can't hard fail because there are some valid errors, just
                                Err(err) => {
                                    resolved_map.insert(event_id, Err(err.to_string()));
                                    // We have to give up on this PDU
                                    continue 'outer;
                                }
                            },
                        }
                    }
                    prev_ids.push(PrevEvents::new(
                        &prev_fork_ids.into_iter().collect::<Vec<_>>(),
                    ));
                    missing.push(PrevEvents::new(&missing_fork));
                }
                // All done finding missing events
                None => {
                    break 'inner;
                }
            }
        }

        // We can treat this event as sequential and simply apply it against the current state of the room
        // because we know that state
        if missing.is_empty() {
            // Back to the original incoming event
            // If it is a non state event we still must add it and associate a statehash with the pdu_id
            if value.get("state_key").is_none() {
                // TODO: Some auth needs to be done for non state events
                if !db.rooms.is_joined(&pdu.sender, room_id)? {
                    error!("Sender is not joined {}", pdu.kind);
                    resolved_map.insert(event_id, Err("Sender not found in room".into()));
                    continue 'outer;
                }

                append_state(&db, &pdu)?;
                resolved_map.insert(event_id, Ok::<(), String>(()));
                continue 'outer;
            } else {
                let incoming = pdu.convert_for_state_res();
                match state_res::StateResolution::apply_event(
                    room_id,
                    &RoomVersionId::Version6,
                    incoming.clone(),
                    &seen
                        .iter()
                        .map(|(k, v)| (k.clone(), v.event_id.clone()))
                        .collect::<BTreeMap<_, _>>(),
                    Some(
                        seen.iter()
                            .map(|(_k, v)| (v.event_id.clone(), v.convert_for_state_res()))
                            .collect::<BTreeMap<_, _>>(),
                    ), // TODO: make mut and keep around, this is all the auth events
                    &db.rooms,
                ) {
                    Ok(true) => {
                        append_state(&db, &pdu)?;
                        resolved_map.insert(event_id, Ok::<(), String>(()));
                        continue 'outer;
                    }
                    Ok(false) => {
                        resolved_map.insert(event_id, Err("Failed event auth".to_string()));
                        error!("Failed sequential event auth for incoming");
                        continue 'outer;
                    }
                    Err(err) => {
                        resolved_map.insert(event_id, Err(err.to_string()));
                        error!("{}", err);
                        continue 'outer;
                    }
                }
            }
        }

        // Well, now we have to actually do a bunch of work :(
        // The steps are as follows
        // 1. Rebuild the sending servers forward extremity, ignoring our own fork
        //   a) iterate "oldest" -> most recent authenticating each event with the state after the previous
        //   b) build a `snapshot_map` containing the state after the event for each missing event (EventId -> StateMap<EventId>)
        // 2. Build our side of the fork (TODO do we have to re-auth these, is state at an event relative to the server its from)
        // 3. resolve the two states (our current with the state after the most recent missing event)

        // Now build up state
        let mut state_snapshot = seen
            .iter()
            .map(|(k, v)| (k.clone(), v.event_id.clone()))
            .collect::<BTreeMap<_, _>>();

        // TODO: So this is super memory inefficient we clone the state_snapshot every time
        // we need it for state events and non
        let mut snapshot_map = BTreeMap::new();
        snapshot_map.insert(seen_id.clone().unwrap(), state_snapshot.clone());

        let accum_event_map = seen
            .iter()
            .map(|(_, v)| (v.event_id.clone(), v.convert_for_state_res()))
            .chain(
                missing
                    .iter()
                    .cloned()
                    .flatten()
                    .map(|pdu| (pdu.event_id.clone(), pdu.convert_for_state_res())),
            )
            .collect::<BTreeMap<_, Arc<state_res::StateEvent>>>();

        // 4. Passes authorization rules based on the event's auth events, otherwise it is rejected.
        // 5. Passes authorization rules based on the state at the event, otherwise it is rejected.
        for missing_pdu in missing.iter().rev() {
            match missing_pdu {
                PrevEvents::Sequential(missing_pdu) => {
                    // For state events
                    if missing_pdu.state_key.is_some() {
                        let missing_pdu = missing_pdu.convert_for_state_res();
                        match state_res::StateResolution::apply_event(
                            room_id,
                            &RoomVersionId::Version6,
                            missing_pdu.clone(),
                            &state_snapshot,
                            Some(accum_event_map.clone()), // TODO: make mut and check on Ok(..) ?
                            &db.rooms,
                        ) {
                            Ok(true) => {
                                // TODO: do we need this
                                assert_eq!(room_id, missing_pdu.room_id());

                                // We can't add to DB yet since we don't know if it passes
                                // current room state
                                // append_state(&db, &PduEvent::from(&*missing_pdu))?;

                                // Only after the state is recorded in the DB can we update the state_snapshot
                                // This will update the state snapshot so it is correct next loop through
                                state_snapshot.insert(
                                    (missing_pdu.kind(), missing_pdu.state_key()),
                                    missing_pdu.event_id(),
                                );
                                // Keep track of the state after for resolution
                                snapshot_map.insert(missing_pdu.event_id(), state_snapshot.clone());
                            }
                            Ok(false) => {
                                error!(
                                    "apply missing: {}",
                                    serde_json::to_string_pretty(&*missing_pdu).unwrap()
                                );
                                continue;
                            }
                            Err(e) => {
                                error!("{}", e);
                                // This is not a fatal error but we do eventually need to handle
                                // events failing that are not the incoming events
                                // TODO: what to do when missing events fail (not incoming events)
                            }
                        }
                    } else {
                        // TODO: Some auth needs to be done for non state events
                        if !db
                            .rooms
                            .is_joined(&missing_pdu.sender, &missing_pdu.room_id)?
                        {
                            error!("fork Sender is not joined {}", missing_pdu.kind);
                            // TODO: we probably should not be getting events for different rooms
                            continue;
                        }

                        // TODO: a better way to signal non state events...
                        snapshot_map.insert(missing_pdu.event_id.clone(), state_snapshot.clone());
                        // Continue this inner for loop adding all the missing events
                    }
                }
                PrevEvents::Fork(pdus) => {
                    let mut state_sets = BTreeSet::new();
                    for pdu in pdus {
                        let mut state_at = state_snapshot.clone();
                        if pdu.state_key.is_some() {
                            state_at.insert(
                                (pdu.kind.clone(), pdu.state_key.clone().unwrap()),
                                pdu.event_id.clone(),
                            );
                        }
                        state_sets.insert(state_at);
                    }

                    if state_sets.len() <= 1 {
                        for missing_pdu in pdus.iter() {
                            // For state events
                            if missing_pdu.state_key.is_some() {
                                let missing_pdu = missing_pdu.convert_for_state_res();
                                match state_res::StateResolution::apply_event(
                                    room_id,
                                    &RoomVersionId::Version6,
                                    missing_pdu.clone(),
                                    &state_snapshot,
                                    Some(accum_event_map.clone()), // TODO: make mut and check on Ok(..) ?
                                    &db.rooms,
                                ) {
                                    Ok(true) => {
                                        // TODO: do we need this
                                        assert_eq!(room_id, missing_pdu.room_id());

                                        state_snapshot.insert(
                                            (missing_pdu.kind(), missing_pdu.state_key()),
                                            missing_pdu.event_id(),
                                        );
                                        snapshot_map
                                            .insert(missing_pdu.event_id(), state_snapshot.clone());
                                    }
                                    Ok(false) => {
                                        error!(
                                            "apply missing fork: {}",
                                            serde_json::to_string_pretty(&*missing_pdu).unwrap()
                                        );
                                        continue;
                                    }
                                    Err(e) => {
                                        error!("fork state-res: {}", e);
                                        // TODO: what to do when missing events fail (not incoming events)
                                    }
                                }
                            } else {
                                // TODO: Some auth needs to be done for non state events
                                if !db
                                    .rooms
                                    .is_joined(&missing_pdu.sender, &missing_pdu.room_id)?
                                {
                                    error!("fork Sender is not joined {}", missing_pdu.kind);
                                    // TODO: we probably should not be getting events for different rooms
                                    continue;
                                }
                                snapshot_map
                                    .insert(missing_pdu.event_id.clone(), state_snapshot.clone());
                                // Continue this inner for loop adding all the missing events
                            }
                        }
                    } else {
                        match state_res::StateResolution::resolve(
                            room_id,
                            &RoomVersionId::Version6,
                            &state_sets.into_iter().collect::<Vec<_>>(),
                            Some(accum_event_map.clone()), // TODO: make mut and check on Ok(..) ?
                            &db.rooms,
                        ) {
                            Ok(resolved) => {
                                for id in resolved
                                    .values()
                                    .filter(|id| pdus.iter().any(|pduid| pduid.event_id == **id))
                                {
                                    snapshot_map.insert(id.clone(), resolved.clone());
                                }
                            }
                            Err(err) => {
                                error!("{}", err);
                            }
                        }
                    }
                }
            }
        }

        // We know these events are valid for each state at the event
        // we have already authed them
        let known_fork = if let Some(id) = seen_id {
            db.rooms.state_from(room_id, &id)?
        } else {
            vec![]
        };
        for pdu in known_fork.clone().into_iter().rev() {
            if pdu.state_key.is_some() {
                seen.insert((pdu.kind.clone(), pdu.state_key.clone().unwrap()), pdu);
            }
        }

        let current_room_state = seen
            .into_iter()
            .map(|(k, v)| (k, v.event_id))
            .collect::<BTreeMap<_, _>>();

        let mut state_sets = BTreeSet::new();
        state_sets.insert(current_room_state.clone());

        // The first item is the most recent
        if let Some(fork) = missing.first() {
            for pdu in fork.clone().into_iter() {
                if let Some(map) = snapshot_map.get(&pdu.event_id) {
                    state_sets.insert(map.clone());
                }
            }
        }

        let mut state_sets = state_sets.into_iter().collect::<Vec<_>>();
        // If we have actual differences resolve
        if state_sets.len() > 1 {
            // Set the incoming event to have parents from both forks
            // ours/theirs
            pdu.prev_events = missing
                .first()
                .cloned()
                .into_iter()
                .flatten()
                .map(|pdu| pdu.event_id)
                .chain(known_fork.first().cloned().map(|pdu| pdu.event_id))
                .collect();

            // The incoming event is a child of both forks now
            for set in &mut state_sets {
                set.insert(
                    (pdu.kind.clone(), pdu.state_key.clone().unwrap()),
                    pdu.event_id.clone(),
                );
            }

            // If we have holes or a fork I am less sure what can be guaranteed about our state?
            // Or what must be done to fix holes and forks?
            match state_res::StateResolution::resolve(
                room_id,
                &RoomVersionId::Version6,
                &state_sets,
                Some(accum_event_map.clone()), // TODO: make mut and check on Ok(..) ?
                &db.rooms,
            ) {
                Ok(resolved) if resolved.values().any(|id| id == &event_id) => {
                    for resolved_missing in missing
                        .into_iter()
                        .rev() // We want the oldest pdu's first
                        .flatten()
                        .filter(|pdu| resolved.values().any(|res_id| res_id == &pdu.event_id))
                    {
                        let count = db.globals.next_count()?;
                        let mut pdu_id = room_id.as_bytes().to_vec();
                        pdu_id.push(0xff);
                        pdu_id.extend_from_slice(&count.to_be_bytes());
                        db.rooms.append_pdu(
                            &resolved_missing,
                            &crate::utils::to_canonical_object(&resolved_missing)
                                .expect("PDU is valid canonical JSON"),
                            count,
                            pdu_id.into(),
                            &db.globals,
                            &db.account_data,
                            &db.admin,
                        )?;
                    }

                    let count = db.globals.next_count()?;
                    let mut pdu_id = room_id.as_bytes().to_vec();
                    pdu_id.push(0xff);
                    pdu_id.extend_from_slice(&count.to_be_bytes());

                    // Since we know the state we force_state
                    // saving the incoming pdu's id with our new state
                    db.rooms.force_state_with_pdu(
                        &*pdu_id,
                        room_id,
                        resolved
                            .iter()
                            .map(|(k, v)| {
                                (
                                    k.clone(),
                                    serde_json::to_vec(
                                        &db.rooms
                                            .get_pdu(v)
                                            .expect("db err")
                                            .expect("we know of all the pdus"),
                                    )
                                    .expect("serde can serialize pdus"),
                                )
                            })
                            .collect(),
                    )?;
                    db.rooms.append_pdu(
                        &pdu,
                        &value,
                        count,
                        pdu_id.into(),
                        &db.globals,
                        &db.account_data,
                        &db.admin,
                    )?;
                    resolved_map.insert(event_id, Ok::<(), String>(()));
                }
                Ok(resolved) => {
                    for resolved_missing in missing
                        .into_iter()
                        .flatten()
                        .filter(|pdu| resolved.values().any(|res_id| res_id == &pdu.event_id))
                    {
                        let count = db.globals.next_count()?;
                        let mut pdu_id = room_id.as_bytes().to_vec();
                        pdu_id.push(0xff);
                        pdu_id.extend_from_slice(&count.to_be_bytes());
                        db.rooms.append_pdu(
                            &resolved_missing,
                            &crate::utils::to_canonical_object(&resolved_missing)
                                .expect("PDU is valid canonical JSON"),
                            count,
                            pdu_id.into(),
                            &db.globals,
                            &db.account_data,
                            &db.admin,
                        )?;
                    }
                    resolved_map.insert(event_id, Err("Failed event auth".into()));
                    error!(
                        "auth failed: {}",
                        serde_json::to_string_pretty(&pdu).unwrap()
                    );
                }
                Err(err) => {
                    resolved_map.insert(event_id, Err(err.to_string()));
                    error!("{}", err);
                }
            }
        // If we have iterated through the incoming missing events sequentially we know that
        // the original incoming event is the youngest child and so can be simply authed and appended
        // to the state
        } else {
            // If it is a non state event we still must add it and associate a statehash with the pdu_id
            if pdu.state_key.is_none() {
                // TODO: Some auth needs to be done for non state events
                if !db.rooms.is_joined(&pdu.sender, room_id)? {
                    error!("Sender is not joined {}", pdu.kind);
                    resolved_map.insert(event_id, Err("Sender not found in room".into()));
                    continue 'outer;
                }

                append_state(&db, &pdu)?;
                resolved_map.insert(event_id, Ok::<(), String>(()));
            } else {
                let incoming = pdu.convert_for_state_res();
                match state_res::StateResolution::apply_event(
                    room_id,
                    &RoomVersionId::Version6,
                    incoming,
                    &current_room_state,
                    Some(accum_event_map), // TODO: make mut and check on Ok(..) ?
                    &db.rooms,
                ) {
                    Ok(true) => {
                        append_state(&db, &pdu)?;
                        resolved_map.insert(event_id, Ok::<(), String>(()));
                    }
                    Ok(false) => {
                        resolved_map.insert(event_id, Err("Failed event auth".to_string()));
                        error!("Failed sequential event auth for incoming");
                    }
                    Err(err) => {
                        resolved_map.insert(event_id, Err(err.to_string()));
                        error!("{}", err);
                    }
                }
            }
        }
    }

    Ok(dbg!(send_transaction_message::v1::Response { pdus: resolved_map }).into())
}

fn append_state(db: &Database, pdu: &PduEvent) -> Result<()> {
    let count = db.globals.next_count()?;
    let mut pdu_id = pdu.room_id.as_bytes().to_vec();
    pdu_id.push(0xff);
    pdu_id.extend_from_slice(&count.to_be_bytes());

    db.rooms.append_to_state(&pdu_id, pdu)?;
    db.rooms.append_pdu(
        pdu,
        &utils::to_canonical_object(pdu).expect("Pdu is valid canonical object"),
        count,
        pdu_id.clone().into(),
        &db.globals,
        &db.account_data,
        &db.admin,
    )
}

#[cfg_attr(
    feature = "conduit_bin",
    post("/_matrix/federation/v1/get_missing_events/<_>", data = "<body>")
)]
pub fn get_missing_events_route<'a>(
    db: State<'a, Database>,
    body: Ruma<get_missing_events::v1::Request<'_>>,
) -> ConduitResult<get_missing_events::v1::Response> {
    if !db.globals.federation_enabled() {
        return Err(Error::bad_config("Federation is disabled."));
    }

    let mut queued_events = body.latest_events.clone();
    let mut events = Vec::new();

    let mut i = 0;
    while i < queued_events.len() && events.len() < u64::from(body.limit) as usize {
        if let Some(pdu) = db.rooms.get_pdu_json(&queued_events[i])? {
            if body.earliest_events.contains(
                &serde_json::from_value(
                    pdu.get("event_id")
                        .cloned()
                        .ok_or_else(|| Error::bad_database("Event in db has no event_id field."))?,
                )
                .map_err(|_| Error::bad_database("Invalid event_id field in pdu in db."))?,
            ) {
                i += 1;
                continue;
            }
            queued_events.extend_from_slice(
                &serde_json::from_value::<Vec<EventId>>(
                    pdu.get("prev_events").cloned().ok_or_else(|| {
                        Error::bad_database("Invalid prev_events field of pdu in db.")
                    })?,
                )
                .map_err(|_| Error::bad_database("Invalid prev_events content in pdu in db."))?,
            );
            events.push(serde_json::from_value(pdu).expect("Raw<..> is always valid"));
        }
        i += 1;
    }

    Ok(get_missing_events::v1::Response { events }.into())
}

#[cfg_attr(
    feature = "conduit_bin",
    get("/_matrix/federation/v1/query/profile", data = "<body>")
)]
pub fn get_profile_information_route<'a>(
    db: State<'a, Database>,
    body: Ruma<get_profile_information::v1::Request<'_>>,
) -> ConduitResult<get_profile_information::v1::Response> {
    if !db.globals.federation_enabled() {
        return Err(Error::bad_config("Federation is disabled."));
    }

    let mut displayname = None;
    let mut avatar_url = None;

    match &body.field {
        // TODO: what to do with custom
        Some(ProfileField::_Custom(_s)) => {}
        Some(ProfileField::DisplayName) => displayname = db.users.displayname(&body.user_id)?,
        Some(ProfileField::AvatarUrl) => avatar_url = db.users.avatar_url(&body.user_id)?,
        None => {
            displayname = db.users.displayname(&body.user_id)?;
            avatar_url = db.users.avatar_url(&body.user_id)?;
        }
    }

    Ok(get_profile_information::v1::Response {
        displayname,
        avatar_url,
    }
    .into())
}

/*
#[cfg_attr(
    feature = "conduit_bin",
    get("/_matrix/federation/v2/invite/<_>/<_>", data = "<body>")
)]
pub fn get_user_devices_route<'a>(
    db: State<'a, Database>,
    body: Ruma<membership::v1::Request<'_>>,
) -> ConduitResult<get_profile_information::v1::Response> {
    if !db.globals.federation_enabled() {
        return Err(Error::bad_config("Federation is disabled."));
    }

    let mut displayname = None;
    let mut avatar_url = None;

    match body.field {
        Some(ProfileField::DisplayName) => displayname = db.users.displayname(&body.user_id)?,
        Some(ProfileField::AvatarUrl) => avatar_url = db.users.avatar_url(&body.user_id)?,
        None => {
            displayname = db.users.displayname(&body.user_id)?;
            avatar_url = db.users.avatar_url(&body.user_id)?;
        }
    }

    Ok(get_profile_information::v1::Response {
        displayname,
        avatar_url,
    }
    .into())
}
*/