'use strict';

const express = require('express');
const next = require('next');
const fs = require('fs');
const path = require('path');
const sqlite3 = require('sqlite3').verbose();
const nodeGit = require('nodegit');

const repositoryDirectory = './user-content-access/';
const dbFile = './gitcub.db';

const dev = process.env.NODE_ENV !== 'production';
const port = 3000;
const app = next({ dev });
const handle = app.getRequestHandler();

const directoryExists = (path) => fs.existsSync(path) ? fs.statSync(path).isDirectory() : false;

const repositoryExists = (name, rows) => (
  directoryExists(repositoryDirectory + name + '.git') && rows.some((x) => x.name === name)
);

const sendResult = (res, resultType, resultContent = '') => {
  const result = {
    resultType: resultType,
    resultContent: resultContent,
  }

  res.json(result);
}

const sendRepositoryResult = (res, pathArray, tree) => {
  const recursion = (pathArray, tree) => {
    if (pathArray.length > 0) {
      const entries = tree.entries();
      const isMatchingTree = (x) => x.name() === pathArray[0] && x.isTree();
      const isMatchingBlob = (x) => x.name() === pathArray[0] && x.isBlob();

      if (entries.some(isMatchingTree)) {
        entries.find(isMatchingTree).getTree().then((tree) => {
          pathArray.shift();
          recursion(pathArray, tree);
        });
      } else if (pathArray.length === 1) {
        if (entries.some(isMatchingBlob)) {
          entries.find(isMatchingBlob).getBlob().then((blob) => {
            if (blob.isBinary()) {
              sendResult(res, 'binaryBlob');
            } else {
              const text = blob.toString();
              sendResult(res, 'textBlob', text);
            }
          });
        } else {
          sendResult(res, 'error', 'File or directory does not exist.');
        }
      } else {
        sendResult(res, 'error', 'File or directory does not exist.');
      }
    } else {
      const dirList = tree.entries().map((entry) => entry.name());
      sendResult(res, 'treeContents', dirList);
    }
  }

  recursion(pathArray, tree);
}

const sendAPIResult = (req, res, rows) => {
  if (req.originalUrl.indexOf('\0') === -1) {
    const pathNormalized = path.normalize(req.path);
    const pathArray = pathNormalized.split('/').filter((x) => x.length > 0);
    
    // remove 'api'
    pathArray.shift();
    
    if (pathArray.length > 0) {
      if (repositoryExists(pathArray[0], rows)) {
        const pathToRepo = repositoryDirectory + pathArray[0] + '.git'
        nodeGit.Repository.openBare(pathToRepo)
          .then((repo) => repo.getMasterCommit())
          .then((commit) => commit.getTree())
          .then((tree) => {
            pathArray.shift();
            sendRepositoryResult(res, pathArray, tree);
          });
      } else {
        sendResult(res, 'error', 'Repository does not exist.');
      }
    } else {
      
      // note, this case is not yet reachable
      sendResult(res, 'error', 'Repository not specified.');
    }
  } else {
    sendResult(res, 'error', 'Null byte found in url. Nice try :)');
  }
}

app.prepare()
.then(() => {
  const server = express();
  const db = new sqlite3.Database(dbFile, sqlite3.OPEN_READWRITE);

  server.get('/api/*', (req, res) => {
    db.all('select name from repositories', (err, rows) => {
      sendAPIResult(req, res, rows);
    });
  });

  server.get('*', (req, res) => {
    return handle(req, res);
  });

  server.listen(port, () => {
    console.log(`Example app listening on port ${port}`);
  });
})
.catch((ex) => {
  console.error(ex.stack);
  process.exit(1);
});