'use strict';

var mongo = require('mongodb');
var fs = require('fs');

var cachedDb;
var cachedClient;
var cachedBoards;
var cachedPosts;
var cachedThreads;

function lookForThreads(boardUri, relation, callback) {

  cachedThreads.find({
    boardUri : boardUri,
    threadId : {
      $in : Object.keys(relation).map(function(element) {
        return +element;
      })
    }
  }, {
    projection : {
      _id : 0,
      threadId : 1
    }
  }).toArray(function(error, results) {

    if (error) {
      return callback(error);
    }

    for (var i = 0; i < results.length; i++) {
      delete relation[results[i].threadId];
    }

    callback();

  });

}

function processBoard(boardUri, results, callback, index) {

  index = index || 0;

  cachedPosts.find({
    boardUri : boardUri
  }, {
    projection : {
      threadId : 1,
      _id : 0,
      postId : 1
    }
  }).sort({
    _id : 1
  }).skip(index * 100).limit(100).toArray(function(error, foundPosts) {

    if (error || !foundPosts.length) {
      return callback(error);
    }

    var relation = results[boardUri] || {};
    results[boardUri] = relation;

    for (var i = 0; i < foundPosts.length; i++) {

      var post = foundPosts[i];

      var threadList = relation[post.threadId] || [];

      relation[post.threadId] = threadList;

      threadList.push(post.postId);

    }

    lookForThreads(boardUri, relation, function(error) {

      if (error) {
        return callback(error);
      }

      processBoard(boardUri, results, callback, ++index);

    });

  });

}

function initCheck(callback, toSkip, results) {

  toSkip = toSkip || 0;
  results = results || {};

  cachedBoards.find().sort({
    _id : 1
  }).skip(toSkip).toArray(function(error, list) {

    if (error) {
      callback(error);
    } else if (!list.length) {
      callback(null, results);
    } else {

      processBoard(list[0].boardUri, results, function(error) {

        if (error) {
          callback(error);
        } else {
          initCheck(callback, ++toSkip, results);
        }

      });

    }

  });

}

function connect(connectString, dbToUse, callback, attempts) {

  attempts = attempts || 0;

  mongo.MongoClient.connect(connectString, {
    useNewUrlParser : true
  }, function connectedDb(error, client) {

    if (error) {

      if (attempts > 9) {
        callback(error);
      } else {

        console.log(error);
        console.log('Retrying in 10 seconds');

        setTimeout(function() {
          connect(connectString, dbToUse, callback, ++attempts);
        }, 10000);
      }

    } else {

      cachedClient = client;
      cachedDb = client.db(dbToUse);

      cachedBoards = cachedDb.collection('boards');
      cachedPosts = cachedDb.collection('posts');
      cachedThreads = cachedDb.collection('threads');

      initCheck(callback);
    }

  });

}

function init(callback) {

  var dbSettings = JSON.parse(fs.readFileSync(__dirname + '/settings/db.json'));

  var connectString = 'mongodb://';

  if (dbSettings.user) {
    connectString += dbSettings.user + ':' + dbSettings.password + '@';
  }

  connectString += dbSettings.address + ':';
  connectString += dbSettings.port + '/' + dbSettings.db;

  if (dbSettings.ssl) {
    connectString += '?ssl=true';
  }

  connect(connectString, dbSettings.db, callback);

}

init(function(error, results) {

  if (error) {
    console.log(error);
  } else {

    console.log(JSON.stringify(results, null, 2));

    var orList = [];

    for ( var key in results) {

      var threadList = Object.keys(results[key]).map(function(element) {
        return +element;
      });

      if (!threadList.length) {
        continue;
      }

      orList.push({
        boardUri : key,
        threadId : {
          $in : threadList
        }
      });

    }

    if (!orList.length) {
      return cachedClient.close();
    }

    cachedPosts.deleteMany({
      $or : orList
    }, function(error, result) {

      if (error) {
        console.log(error);
      }

      cachedClient.close();
    });

  }

});