#!/usr/bin/env node

/* contents of .nvmrc
18.13.0
*/

/* contents of package.json:
{
  "dependencies": {
    "sqlite3": "^5.0.8"
  }
}
*/

// API doc https://gitgud.io/InfinityNow/LynxChan/-/blob/master/doc/Json.txt

const https = require('https')
const sqlite3 = require('sqlite3')

// Board to be archived, can be overriden by passing an argument `node app.js ausneets`
const defaultBoard = 'polru'
var board = defaultBoard
const arg = process.argv.slice(2)[0]
if (arg) {
  board = arg
}

const db = new sqlite3.Database(`endchan-${board}.db`)

async function getJson(url) {
  return new Promise((resolve) => {
      let data = ''

      https.get(url, res => {
          res.on('data', chunk => { data += chunk })
          res.on('end', () => {
            resolve(JSON.parse(data))
          })
      })
  })
}

async function dbGet(query, args){
  return new Promise(function(resolve, reject) {
      db.get(query, args, function(err, row) {
         if (err) { return reject(err) }
         resolve(row)
       })
  })
}

async function archiveThread(thread) {
  const threadId = thread['threadId']
  const threadJson = await getJson(`https://endchan.gg/${board}/res/${threadId}.json`)
  var posts = threadJson.posts
  posts.unshift(threadJson)

  for (var postIndex in posts) {
    const post = posts[postIndex]
    const files = post['files'].map((arr) => {
      return arr.originalName
    })
    .join(',')

    db.run(`
    INSERT OR REPLACE INTO posts
    (threadId, postId, message, id, flagCode, creation, name, email, subject, files)
    VALUES
    (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
    `,
      [
        threadId,
        postIndex == 0 ? threadId: post['postId'],
        post['message'],
        post['id'],
        post['flagCode'],
        post['creation'],
        post['name'],
        post['email'],
        post['subject'],
        files
      ])
  }

  return threadJson
}

async function start() {
  console.log('...fetching threads list...')
  const threads = await getJson(`https://endchan.gg/${board}/catalog.json`)
  threads.sort((a, b) => a.lastBump > b.lastBump)

  for (var threadIndex in threads) {
    const thread = threads[threadIndex]
    console.log(`Updating thread with id: ${thread.threadId}, lastBump: ${thread.lastBump}`)

    const oldLastBumpRow = await dbGet(`
    SELECT lastBump FROM threads
    WHERE threadId = ?
    `,
    [thread['threadId']])

    if (oldLastBumpRow && oldLastBumpRow.lastBump === thread['lastBump']) {
      console.log('Up to date, finishing...')
      break
    }

    let opPost = await archiveThread(thread)

    db.run(`
    INSERT OR REPLACE INTO threads
    (threadId, lastBump)
    VALUES
    (?, ?)
    `,
      [
        thread['threadId'],
        thread['lastBump']
      ])
  }
}

db.serialize(() => {
  db.run(`
    CREATE TABLE IF NOT EXISTS "threads" (
        "threadId"  INTEGER,
        "lastBump" DATE,
        PRIMARY KEY("threadId")
    );
    `)

  db.run(`
    CREATE TABLE IF NOT EXISTS "posts" (
        "threadId" TEXT,
        "postId"    INTEGER,
        "message" TEXT,
        "id" TEXT,
        "flagCode" TEXT,
        "creation" DATE,
        "name" TEXT,
        "email" TEXT,
        "subject" TEXT,
        "files" TEXT,
        PRIMARY KEY("postId")
    );
    `)

  start()
})