import Service, { inject as service } from '@ember/service';
import { get } from '@ember/object';
import { next } from '@ember/runloop';

import { CACHE_CONTROL, CONTENT_TYPE } from 'consul-ui/utils/http/headers';
import {
  HEADERS_TOKEN as CONSUL_TOKEN,
  HEADERS_PARTITION as CONSUL_PARTITION,
  HEADERS_NAMESPACE as CONSUL_NAMESPACE,
  HEADERS_DATACENTER as CONSUL_DATACENTER,
} from 'consul-ui/utils/http/consul';

import createURL from 'consul-ui/utils/http/create-url';
import createHeaders from 'consul-ui/utils/http/create-headers';
import createQueryParams from 'consul-ui/utils/http/create-query-params';

// reopen EventSources if a user changes tab
export const restartWhenAvailable = function(client) {
  return function(e) {
    // setup the aborted connection restarting
    // this should happen here to avoid cache deletion
    const status = get(e, 'errors.firstObject.status');
    // TODO: Reconsider a proper custom HTTP code
    // -1 is a UI only error code for 'user switched tab'
    if (status === '-1') {
      // Any '0' errors (abort) should possibly try again, depending upon the circumstances
      // whenAvailable returns a Promise that resolves when the client is available
      // again
      return client.whenAvailable(e);
    }
    throw e;
  };
};
const QueryParams = {
  stringify: createQueryParams(encodeURIComponent),
};
const parseHeaders = createHeaders();

const parseBody = function(strs, ...values) {
  let body = {};
  const doubleBreak = strs.reduce(function(prev, item, i) {
    // Ensure each line has no whitespace either end, including empty lines
    item = item
      .split('\n')
      .map(item => item.trim())
      .join('\n');
    if (item.indexOf('\n\n') !== -1) {
      return i;
    }
    return prev;
  }, -1);
  if (doubleBreak !== -1) {
    // This merges request bodies together, so you can specify multiple bodies
    // in the request and it will merge them together.
    // Turns out we never actually do this, so it might be worth removing as it complicates
    // matters slightly as we assumed post bodies would be an object.
    // This actually works as it just uses the value of the first object, if its an array
    // it concats
    body = values.splice(doubleBreak).reduce(function(prev, item, i) {
      switch (true) {
        case Array.isArray(item):
          if (i === 0) {
            prev = [];
          }
          return prev.concat(item);
        case typeof item !== 'string':
          return {
            ...prev,
            ...item,
          };
        default:
          return item;
      }
    }, body);
  }
  return [body, ...values];
};

const CLIENT_HEADERS = [CACHE_CONTROL, 'X-Request-ID', 'X-Range', 'Refresh'];
export default class HttpService extends Service {
  @service('dom') dom;
  @service('env') env;
  @service('client/connections') connections;
  @service('client/transports/xhr') transport;
  @service('settings') settings;
  @service('encoder') encoder;
  @service('store') store;

  init() {
    super.init(...arguments);
    this._listeners = this.dom.listeners();
    this.parseURL = createURL(encodeURIComponent, obj => QueryParams.stringify(this.sanitize(obj)));
    const uriTag = this.encoder.uriTag();
    this.cache = (data, id) => {
      // interpolate the URI
      data.uri = id(uriTag);
      // save the time we received it for cache management purposes
      data.SyncTime = new Date().getTime();
      // save the data to the cache
      return this.store.push(
        {
          data: {
            id: data.uri,
            // the model is encoded as the protocol in the URI
            type: new URL(data.uri).protocol.slice(0, -1),
            attributes: data
          }
        }
      );
    }
  }

  sanitize(obj) {
    if (!this.env.var('CONSUL_NSPACES_ENABLED')) {
      delete obj.ns;
    } else {
      if (typeof obj.ns === 'undefined' || obj.ns === null || obj.ns === '') {
        delete obj.ns;
      }
    }
    if (!this.env.var('CONSUL_PARTITIONS_ENABLED')) {
      delete obj.partition;
    } else {
      if (typeof obj.partition === 'undefined' || obj.partition === null || obj.partition === '') {
        delete obj.partition;
      }
    }
    return obj;
  }

  willDestroy() {
    this._listeners.remove();
    super.willDestroy(...arguments);
  }

  url() {
    return this.parseURL(...arguments);
  }

  body() {
    const res = parseBody(...arguments);
    this.sanitize(res[0]);
    return res;
  }

  requestParams(strs, ...values) {
    // first go to the end and remove/parse the http body
    const [body, ...urlVars] = this.body(...arguments);
    // with whats left get the method off the front
    const [method, ...urlParts] = this.url(strs, ...urlVars).split(' ');
    // with whats left use the rest of the line for the url
    // with whats left after the line, use for the headers
    const [url, ...headerParts] = urlParts.join(' ').split('\n');
    const params = {
      url: url.trim(),
      method: method.trim(),
      headers: {
        [CONTENT_TYPE]: 'application/json; charset=utf-8',
        ...parseHeaders(headerParts),
      },
      body: null,
      data: body,
    };
    // Remove and save things that shouldn't be sent in the request
    params.clientHeaders = CLIENT_HEADERS.reduce(function(prev, item) {
      if (typeof params.headers[item] !== 'undefined') {
        prev[item.toLowerCase()] = params.headers[item];
        delete params.headers[item];
      }
      return prev;
    }, {});
    if (typeof body !== 'undefined') {
      // Only read add HTTP body if we aren't GET
      // Right now we do this to avoid having to put data in the templates
      // for write-like actions
      // potentially we should change things so you _have_ to do that
      // as doing it this way is a little magical
      if (params.method !== 'GET') {
        if (params.headers[CONTENT_TYPE].indexOf('json') !== -1) {
          params.body = JSON.stringify(params.data);
        } else {
          if (
            (typeof params.data === 'string' && params.data.length > 0) ||
            Object.keys(params.data).length > 0
          ) {
            params.body = params.data;
          }
        }
      } else {
        const str = QueryParams.stringify(params.data);
        if (str.length > 0) {
          if (params.url.indexOf('?') !== -1) {
            params.url = `${params.url}&${str}`;
          } else {
            params.url = `${params.url}?${str}`;
          }
        }
      }
    }
    // temporarily reset the headers/content-type so it works the same
    // as previously, should be able to remove this once the data layer
    // rewrite is over and we can assert sending via form-encoded is fine
    // also see adapters/kv content-types in requestForCreate/UpdateRecord
    // also see https://github.com/hashicorp/consul/issues/3804
    params.headers[CONTENT_TYPE] = 'application/json; charset=utf-8';
    return params;
  }

  fetchWithToken(path, params) {
    return this.settings.findBySlug('token').then(token => {
      return fetch(`${path}`, {
        ...params,
        headers: {
          'X-Consul-Token': typeof token.SecretID === 'undefined' ? '' : token.SecretID,
          ...params.headers,
        },
      });
    });
  }
  request(cb) {
    const client = this;
    const cache = this.cache;
    return cb(function(strs, ...values) {
      const params = client.requestParams(...arguments);
      return client.settings.findBySlug('token').then(token => {
        const options = {
          ...params,
          headers: {
            [CONSUL_TOKEN]: typeof token.SecretID === 'undefined' ? '' : token.SecretID,
            ...params.headers,
          },
        };
        const request = client.transport.request(options);
        return new Promise((resolve, reject) => {
          const remove = client._listeners.add(request, {
            open: e => {
              client.acquire(e.target);
            },
            message: e => {
              const headers = {
                ...Object.entries(e.data.headers).reduce(function(prev, [key, value], i) {
                  if (!CLIENT_HEADERS.includes(key)) {
                    prev[key] = value;
                  }
                  return prev;
                }, {}),
                ...params.clientHeaders,
                // Add a 'pretend' Datacenter/Nspace/Partition header, they are
                // not headers the come from the request but we add them here so
                // we can use them later for store reconciliation. Namespace
                // will look at the ns query parameter first, followed by the
                // Namespace property of the users token, defaulting back to
                // 'default' which will mainly be used in OSS
                [CONSUL_DATACENTER]: params.data.dc,
                [CONSUL_NAMESPACE]: params.data.ns || token.Namespace || 'default',
                [CONSUL_PARTITION]: params.data.partition || token.Partition || 'default',
              };
              const respond = function(cb) {
                let res = cb(headers, e.data.response, cache);
                const meta = res.meta || {};
                if(meta.version === 2) {
                  if(Array.isArray(res.body)) {
                    res = new Proxy(
                      res.body,
                      {
                        get: (target, prop) => {
                          switch(prop) {
                            case 'meta':
                              return meta;
                          }
                          return target[prop];
                        }
                      }
                    );
                  } else {
                    res = res.body;
                    res.meta = meta;
                  }
                }
                return res;
              };
              next(() => resolve(respond));
            },
            error: e => {
              next(() => reject(e.error));
            },
            close: e => {
              client.release(e.target);
              remove();
            },
          });
          request.fetch();
        });
      });
    });
  }

  whenAvailable(e) {
    return this.connections.whenAvailable(e);
  }

  abort() {
    return this.connections.purge(...arguments);
  }

  acquire() {
    return this.connections.acquire(...arguments);
  }

  release() {
    return this.connections.release(...arguments);
  }
}