const fs = require('fs');
const fsextra = require('fs-extra');
const path = require('path');
const util = require('util');
const logger = require('winston');

const sanitizeHtml = require('sanitize-html');

const blackfriday = require('./blackfriday.js');

const del = require('delete');
const exec = require('sync-exec');

const inputDirectoryGame = './citra-games-wiki';
const inputDirectoryWiki = './citra-games-wiki.wiki';
const outputDirectoryMd = '../../site/content/game';
const outputDirectoryBoxart = '../../site/static/images/game/boxart';
const outputDirectoryIcons = '../../site/static/images/game/icons';
const outputDirectoryScreenshots = '../../site/static/images/screenshots0';
const outputDirectorySavefiles = '../../site/static/savefiles/';

// The URL
function url(title) {
  return '/wiki/' + title.replace(/\s+/g, '-').toLowerCase();
}

function gitPull(directory, repository) {
  if (fs.existsSync(directory)) {
      logger.info(`Fetching latest from Github : ${directory}`);
      exec(`cd ${directory} && git pull && cd -`);
  } else {
      logger.info(`Cloning repository from Github : ${directory}`);
      exec(`git clone ${repository}`);
  }
}

function getDirectories (srcpath) {
  return fs.readdirSync(srcpath)
    .filter(file => fs.lstatSync(path.join(srcpath, file)).isDirectory())
}

String.prototype.trimNewline = function() {
  let string = this.toString();
  if (string.endsWith('\r\n')) {
    return string.slice(0, -2);
  } else if (string.endsWith('\r') || string.endsWith('\n')) {
    return string.slice(0, -1);
  } else {
    return string;
  }
}

// Fetch game information stored in Github repository.
gitPull(inputDirectoryGame, 'https://github.com/citra-emu/citra-games-wiki.git');

// Fetch game articles stored in Github wiki.
gitPull(inputDirectoryWiki, 'https://github.com/citra-emu/citra-games-wiki.wiki.git');

// Make sure the output directories in Hugo exist.
if (fs.existsSync(outputDirectoryMd) == false) {
    logger.info(`Creating missing output directory: ${outputDirectoryMd}`);
    fs.mkdirSync(outputDirectoryMd);
}

if (fs.existsSync(outputDirectoryBoxart) == false) {
    logger.info(`Creating missing output directory: ${outputDirectoryBoxart}`);
    fs.mkdirSync(outputDirectoryBoxart);
}

if (fs.existsSync(outputDirectoryIcons) == false) {
    logger.info(`Creating missing output directory: ${outputDirectoryIcons}`);
    fs.mkdirSync(outputDirectoryIcons);
}

if (fs.existsSync(outputDirectorySavefiles) == false) {
    logger.info(`Creating missing output directory: ${outputDirectorySavefiles}`);
    fs.mkdirSync(outputDirectorySavefiles);
}

if (fs.existsSync(outputDirectoryScreenshots) == false) {
    logger.info(`Creating missing output directory: ${outputDirectoryScreenshots}`);
    fs.mkdirSync(outputDirectoryScreenshots);
}

try {
  // Loop through each game folder.
  getDirectories(inputDirectoryGame).forEach(function(game) {
    try {
      if (game == '.git') { return; }

      logger.info(`Creating Hugo files for ${game}`);

      // Copy the boxart for the game.
      let boxartPath = `${inputDirectoryGame}/${game}/boxart.png`;
      if (fs.existsSync(boxartPath)) {
        fsextra.copySync(boxartPath, `${outputDirectoryBoxart}/${game}.png`);
      }

      // Copy the icon for the game.
      let iconPath = `${inputDirectoryGame}/${game}/icon.png`;
      if (fs.existsSync(iconPath)) {
        fsextra.copySync(iconPath, `${outputDirectoryIcons}/${game}.png`);
      }

      // Copy the savefiles for the game.
      let inputDirectorySavefilesGame = `${inputDirectoryGame}/${game}/savefiles/`;
      let outputDirectorySavefilesGame = `${outputDirectorySavefiles}/${game}/`;
      let savefileMetadataContents = [];

      if (fs.existsSync(inputDirectorySavefilesGame)) {
        // Create the savefile directory for each game.
        if (fs.existsSync(outputDirectorySavefilesGame) == false) {
            fs.mkdirSync(outputDirectorySavefilesGame);
        }

        // Copy all savefiles into the output folder and store their contents.
        fs.readdirSync(inputDirectorySavefilesGame).forEach(file => {
          if (path.extname(file) == '.zip') {
            fsextra.copySync(`${inputDirectorySavefilesGame}/${file}`, `${outputDirectorySavefilesGame}/${file.replace('.zip', '.zip')}`);
          } else if (path.extname(file) == '.dat') {
            // Store the contents of the file in memory for adding it into the markdown later.
            savefileMetadataContents.push({
              filename: file.replace('.dat', '.zip'),
              contents: fs.readFileSync(`${inputDirectorySavefilesGame}/${file}`, 'utf8').trimNewline()
            });
          }
        });
      }

      // Copy the screenshots for the game.
      let inputDirectoryScreenshotsGame = `${inputDirectoryGame}/${game}/screenshots/`;
      let outputDirectoryScreenshotsGame = `${outputDirectoryScreenshots}/${game}/`;

      if (fs.existsSync(inputDirectoryScreenshotsGame)) {
        // Create the savefile directory for each game.
        if (fs.existsSync(outputDirectoryScreenshotsGame) == false) {
            fs.mkdirSync(outputDirectoryScreenshotsGame);
        }

        // Copy all screenshots into the output folder.
        fs.readdirSync(inputDirectoryScreenshotsGame).forEach(file => {
          if (path.extname(file) == '.png') {
            fsextra.copySync(`${inputDirectoryScreenshotsGame}/${file}`, `${outputDirectoryScreenshotsGame}/${file}`);
          }
        });
      }

      // Create the markdown file to be displayed in Hugo.
      let title = game.replace(/-/g, ' ').slice(0, -3);
      var stats = fs.statSync(`${inputDirectoryGame}/${game}/game.dat`);
      let modified = new Date(util.inspect(stats.mtime));

      let datContents = fs.readFileSync(`${inputDirectoryGame}/${game}/game.dat`, 'utf8').trimNewline();

      var wikiContents = "";
      let wikiPathGame = `${inputDirectoryWiki}/${game}.md`;
      if (fs.existsSync(wikiPathGame)) {
        wikiContents = fs.readFileSync(wikiPathGame, 'utf8').trimNewline();
      } else {
        wikiContents = "## No wiki exists yet for this game.";
      }

      // Fix Blackfriday markdown rendering differences.
      wikiContents = blackfriday.fixLists(wikiContents);
      wikiContents = blackfriday.fixLinks(wikiContents);

      // Read all savefiles from array and copy them into the markdown.
      savefileMetadataContents.forEach(function(savefile) {
        let modified = new Date(util.inspect(stats.mtime));
        datContents += `\r\n\r\n[[ savefiles ]]\r\nfilename = "${savefile.filename}"\r\ndate = "${modified.toISOString()}"\r\n${savefile.contents}`;
      });

      let output = `+++\r\ndate = "${modified.toISOString()}"\r\n${datContents}\r\n+++\r\n\r\n${wikiContents}\r\n`;
      fs.writeFileSync(`${outputDirectoryMd}/${game}.md`, output);
    } catch (ex) {
      logger.error(`${game} failed to generate: ${ex}`);
      logger.error(ex);
    }
  });
} catch (ex) {
  logger.error(ex);
}