"use strict";

import m from "mithril";
import Filter from "../common/filter";
import * as config from "./config";

let fulfillTimestamp = 0;

let unpackedFilters = new WeakMap();

const queries = {
  filter: new WeakMap(),
  last: new WeakMap(),
  limit: new WeakMap(),
  fulfilled: new WeakMap(),
  fulfilling: new WeakSet(),
  mapper: new WeakMap(),
  accessed: new WeakMap(),
  value: new WeakMap()
};

const resources = {};
for (let r of ["devices"])
  resources[r] = {
    objects: new Map(),
    count: new Map(),
    fetch: new Map(),
    combinedFilter: null
  };

class QueryResponse {
  get fulfilled() {
    queries.accessed.set(this, Date.now());
    return !!queries.fulfilled.get(this);
  }

  get value() {
    queries.accessed.set(this, Date.now());
    const mapper = queries.mapper.get(this);
    const value = queries.value.get(this);

    if (mapper) return mapper(queries.value.get(this));
    else return value;
  }
}

function unpackFilter(filter) {
  let f = unpackedFilters.get(filter);
  if (!f) {
    f = f.evaluateExpressions(fulfillTimestamp);
    unpackedFilters.set(filter, f);
  }
  return f;
}

function count(resourceType, filter) {
  let queryResponse = resources[resourceType].count.get(filter.toString());
  if (queryResponse) return queryResponse;

  queryResponse = new QueryResponse();

  resources[resourceType].count.set(filter.toString(), queryResponse);
  queries.filter.set(queryResponse, filter);
  return queryResponse;
}

function limitFilter(resourceType, filter, last) {
  if (resourceType === "devices")
    return filter.and(new Filter(["<=", "DeviceID.ID", last]));
  else return filter.and(new Filter(["<=", "_id", last]));
}

function findMatches(resourceType, filter, limit) {
  let value = [];
  for (let [id, obj] of resources[resourceType].objects.entries())
    if (filter.test(obj)) value.push(id);

  value = value.sort();
  if (limit) value = value.slice(0, limit);

  return value;
}

function inferQuery(resourceType, queryResponse) {
  const limit = queries.limit.get(queryResponse);
  let filter = queries.filter.get(queryResponse);
  filter = unpackFilter(filter);
  let last = queries.last.get(queryResponse);
  if (last || !limit) {
    if (last) filter = limitFilter(resourceType, filter, last);
    if (
      resources[resourceType].combinedFilter &&
      filter.subset(resources[resourceType].combinedFilter)
    )
      queries.fulfilled.set(queryResponse, fulfillTimestamp);
  }

  queries.value.set(queryResponse, findMatches(resourceType, filter, limit));
}

function fetch(resourceType, filter, limit = 0) {
  const key = `${limit}:${filter.toString()}`;
  let queryResponse = resources[resourceType].fetch.get(key);
  if (queryResponse) return queryResponse;

  queryResponse = new QueryResponse();
  resources[resourceType].fetch.set(key, queryResponse);
  queries.filter.set(queryResponse, filter);
  queries.limit.set(queryResponse, limit);
  queries.mapper.set(queryResponse, list =>
    list.map(x => resources[resourceType].objects.get(x))
  );
  inferQuery(resourceType, queryResponse);
  return queryResponse;
}

function fulfill(accessTimestamp, _fulfillTimestamp) {
  let updated = false;

  if (_fulfillTimestamp > fulfillTimestamp) {
    unpackedFilters = new WeakMap();
    for (let resource of Object.values(resources))
      resource.combinedFilter = null;
    fulfillTimestamp = _fulfillTimestamp;
  }

  const allPromises = [];

  for (let [resourceType, resource] of Object.entries(resources))
    for (let queryResponse of resource.count.values()) {
      if (queries.fulfilling.has(queryResponse)) continue;
      if (
        queries.accessed.get(queryResponse) >= accessTimestamp &&
        !(fulfillTimestamp <= queries.fulfilled.get(queryResponse))
      ) {
        queries.fulfilling.add(queryResponse);
        allPromises.push(
          new Promise((resolve, reject) => {
            updated = true;
            let filter = queries.filter.get(queryResponse);
            filter = unpackFilter(filter);
            m
              .request({
                method: "HEAD",
                url:
                  `/api/${resourceType}/?` +
                  m.buildQueryString({
                    filter: filter.toString()
                  }),
                extract: xhr => +xhr.getResponseHeader("x-total-count"),
                background: true
              })
              .then(c => {
                queries.value.set(queryResponse, c);
                queries.fulfilled.set(queryResponse, fulfillTimestamp);
                queries.fulfilling.delete(queryResponse);
                resolve();
              })
              .catch(err => reject(err));
          })
        );
      }
    }

  let toFetchAll = {};

  for (let [resourceType, resource] of Object.entries(resources))
    for (let queryResponse of resource.fetch.values()) {
      if (queries.fulfilling.has(queryResponse)) continue;

      if (
        queries.accessed.get(queryResponse) >= accessTimestamp &&
        !(fulfillTimestamp <= queries.fulfilled.get(queryResponse))
      ) {
        queries.fulfilling.add(queryResponse);
        toFetchAll[resourceType] = toFetchAll[resourceType] || [];
        toFetchAll[resourceType].push(queryResponse);
        const limit = queries.limit.get(queryResponse);
        if (limit)
          allPromises.push(
            new Promise((resolve, reject) => {
              updated = true;
              let filter = queries.filter.get(queryResponse);
              filter = unpackFilter(filter);
              m
                .request({
                  method: "GET",
                  url:
                    `/api/${resourceType}/?` +
                    m.buildQueryString({
                      filter: filter.toString(),
                      limit: 1,
                      skip: limit - 1,
                      projection: "_id"
                    })
                })
                .then(res => {
                  if (res.length)
                    if (resourceType === "devices")
                      queries.last.set(
                        queryResponse,
                        res[0]["DeviceID.ID"].value[0]
                      );
                    else queries.last.set(queryResponse, res[0]["_id"]);
                  else queries.last.delete(queryResponse);
                  resolve();
                })
                .catch(reject);
            })
          );
      }
    }

  return new Promise((resolve, reject) => {
    Promise.all(allPromises)
      .then(() => {
        const allPromises2 = [];
        for (let [resourceType, toFetch] of Object.entries(toFetchAll)) {
          let combinedFilter = null;

          toFetch = toFetch.filter(queryResponse => {
            let filter = queries.filter.get(queryResponse);
            filter = unpackFilter(filter);
            let last = queries.last.get(queryResponse);
            if (last) filter = limitFilter(resourceType, filter, last);

            if (
              resources[resourceType].combinedFilter &&
              filter.subset(resources[resourceType].combinedFilter)
            ) {
              queries.value.set(
                queryResponse,
                findMatches(resourceType, filter)
              );
              queries.fulfilled.set(queryResponse, fulfillTimestamp);
              queries.fulfilling.delete(queryResponse);
              return false;
            }

            combinedFilter = filter.or(combinedFilter);
            return true;
          });

          if (!combinedFilter) return resolve(updated);

          updated = true;
          let combinedFilterDiff = combinedFilter;
          if (resources[resourceType].combinedFilter)
            combinedFilterDiff = combinedFilterDiff.and(
              resources[resourceType].combinedFilter.not()
            );
          resources[resourceType].combinedFilter = combinedFilter.or(
            resources[resourceType].combinedFilter
          );

          allPromises2.push(
            new Promise((resolve2, reject2) => {
              m
                .request({
                  method: "GET",
                  url:
                    `/api/${resourceType}/?` +
                    m.buildQueryString({
                      filter: combinedFilterDiff.toString()
                    })
                })
                .then(res => {
                  for (let r of res)
                    if (resourceType === "devices")
                      resources.devices.objects.set(
                        r["DeviceID.ID"].value[0],
                        r
                      );
                    else resources[resourceType].objects.set(r["_id"], r);

                  for (let queryResponse of toFetch) {
                    let filter = queries.filter.get(queryResponse);
                    filter = unpackFilter(filter);
                    let last = queries.last.get(queryResponse);
                    if (last) filter = limitFilter(resourceType, filter, last);

                    queries.value.set(
                      queryResponse,
                      findMatches(resourceType, filter)
                    );
                    queries.fulfilled.set(queryResponse, fulfillTimestamp);
                    queries.fulfilling.delete(queryResponse);
                  }
                  resolve2();
                })
                .catch(reject2);
            })
          );
        }
        Promise.all(allPromises2)
          .then(() => resolve(updated))
          .catch(reject);
      })
      .catch(reject);
  });
}

function getTimestamp() {
  return fulfillTimestamp;
}

export { count, fetch, fulfill, unpackFilter, getTimestamp };