'use strict';

function deserialize(results) {
  var config = { apis: {}, apps: {}, domains: {} };
  results.apis.forEach(function (api) {
    config.apis[api.id] = api;
    api.domains = [];
    api.domainIds = [];
    api.domainsMap = {};
  });
  results.apps.forEach(function (app) {
    config.apps[app.id] = app;
    app.domains = [];
    app.domainIds = [];
    app.domainsMap = {};
  });

  results.domains.forEach(function (domain) {
    config.domains[domain.id] = domain;
    // as it currently stands each of these will only have one
    /*
    domain.apis = [];
    domain.apiIds = [];
    domain.apisMap = {};
    domain.apps = [];
    domain.appIds = [];
    domain.appsMap = {};
    */
    domain.api = null;
    domain.apiId = null;
    domain.app = null;
    domain.appId = null;
    domain.appsMap = null;
  });

  results.apisDomains.forEach(function (ad) {
    var api = config.apis[ad.apiId];
    var domain = config.domains[ad.domainId];
    if (api && !api.domainsMap[domain.id]) {
      api.domainIds.push(domain.id);
      api.domainsMap[domain.id] = domain;
      api.domains.push(domain);
    }
    if (domain) {
      if (domain.api) {
        console.error("[SANITY FAIL] single domain has multiple frontends in db: '" + domain.id + "'");
      }
      domain.apiId = api.id;
      domain.api = api;
    }
  });

  results.appsDomains.forEach(function (ad) {
    var app = config.apps[ad.appId];
    var domain = config.domains[ad.domainId];
    if (app && !app.domainsMap[domain.id]) {
      app.domainIds.push(domain.id);
      app.domainsMap[domain.id] = domain;
      app.domains.push(domain);
    }
    if (domain) {
      if (domain.app) {
        console.error("[SANITY FAIL] single domain has multiple frontends in db: '" + domain.id + "'");
      }
      domain.appId = app.id;
      domain.app = app;
    }
  });

  return config;
}

module.exports.deserialize = deserialize;
module.exports.create = function (db) {
  console.log('[DB -1]');
  var wrap = require('dbwrap');

  var dir = [
    //
    // Collections
    //
    { tablename: 'apis'
    , idname: 'id'      // io.lds.auth, com.daplie.radio
    , unique: ['id'] 
      // name // LDS Account, Radio
    , indices: ['createdAt', 'updatedAt', 'deletedAt', 'revokedAt', 'name']
    }
  , { tablename: 'apps'
    , idname: 'id'      // io.lds.auth, com.daplie.radio
    , unique: ['id']
    , indices: ['createdAt', 'updatedAt', 'deletedAt', 'revokedAt', 'name']
    }
  , { tablename: 'domains'
    , idname: 'id'      // api.coolaj86.com#radio
    , unique: ['id']
    , indices: ['createdAt', 'updatedAt', 'deletedAt', 'revokedAt', 'name', 'token', 'accountId']
    }

    //
    // Joins
    //
  , { tablename: 'apis_domains'
    , idname: 'id'      // hash(api_id + domain_id)
    , unique: ['id']
    , indices: ['createdAt', 'updatedAt', 'deletedAt', 'apiId', 'domainId']
      // TODO auto-form relations
    , hasMany: ['apis', 'domains']
    }
  , { tablename: 'apps_domains'
    , idname: 'id'      // hash(domain_id + app_id)
    , unique: ['id']
    , indices: ['createdAt', 'updatedAt', 'deletedAt', 'appId', 'domainId']
      // TODO auto-form relations
    , hasMany: ['apps', 'domains']
    }

/*
  , { tablename: 'accounts_apis'
    , idname: 'id'      // hash(account_id + api_id)
    , unique: ['id']
    , indices: ['createdAt', 'updatedAt', 'deletedAt', 'accountId', 'apiId']
      // TODO auto-form relations
    , hasMany: ['accounts', 'apis']
    }
  , { tablename: 'accounts_domains'
    , idname: 'id'      // hash(account_id + domain_id)
    , unique: ['id']
    , indices: ['createdAt', 'updatedAt', 'deletedAt', 'accountId', 'domainId']
      // TODO auto-form relations
    , hasMany: ['accounts', 'domains']
    }
  , { tablename: 'accounts_apps'
    , idname: 'id'      // hash(account_id + static_id)
    , unique: ['id']
    , indices: ['createdAt', 'updatedAt', 'deletedAt', 'accountId', 'staticId']
      // TODO auto-form relations
    , hasMany: ['accounts', 'apps']
    }
*/
  ];

  return wrap.wrap(db, dir).then(function (models) {
    models.Config = {
      get: function () {
        var PromiseA = require('bluebird');

        return PromiseA.all([
          models.Apis.find(null, { limit: 10000 })
        , models.Apps.find(null, { limit: 10000 })
        , models.Domains.find(null, { limit: 10000 })
        , models.ApisDomains.find(null, { limit: 10000 })
        , models.AppsDomains.find(null, { limit: 10000 })
        ]).then(function (args) {
          var results = {
            apis: args[0]
          , apps: args[1]
          , domains: args[2]
          , apisDomains: args[3]
          , appsDomains: args[4]
          };

          // create fixture with which to test
          // console.log(JSON.stringify(results));

          var config = deserialize(results);
          
          return config;
        });
      }
    };

    return models;
  });
};