import { env } from '$env/dynamic/private';
import type { Account, Post, Tag } from '$lib/mastodon/response';
import sqlite3 from 'sqlite3';
const { DEV } = import.meta.env;

const db: sqlite3.Database = new sqlite3.Database('moshingmammut.db');

if (DEV && env.VERBOSE === 'true') {
  sqlite3.verbose();
  db.on('change', (t, d, table, rowid) => {
    console.debug('DB change event', t, d, table, rowid);
  })

  db.on('trace', (sql) => {
    console.debug('Running', sql);
  });

  db.on('profile', (sql) => {
    console.debug('Finished', sql);
  });
}

interface Migration {
  id: number,
  name: string,
  statement: string
}

db.on('open', () => {
  console.log('Opened database');
  db.serialize();
  db.run('CREATE TABLE IF NOT EXISTS "migrations" ("id" integer,"name" TEXT, PRIMARY KEY (id))');
  db.all('SELECT id FROM migrations', (err, rows) => {
    if (err !== null) {
      console.error('Could not fetch existing migrations', err);
      return;
    }
    console.debug('Already applied migrations', rows);
    const appliedMigrations: Set<number> = new Set(rows.map((row: any) => row['id']));
    const toApply = getMigrations().filter(m => !appliedMigrations.has(m.id));
    for (let migration of toApply) {
      db.exec(migration.statement, (err) => {
        if (err !== null) {
          console.error(`Failed to apply migration ${migration.name}`, err);
          return;
        }
        db.run('INSERT INTO migrations (id, name) VALUES(?, ?)', [migration.id, migration.name], (e: Error) => {
          if (e !== null) {
            console.error(`Failed to mark migration ${migration.name} as applied`, e);
            return;
          }
          console.info(`Applied migration ${migration.name}`);
        });
      });
    }
  });
});
db.on('error', (err) => {
  console.error('Error opening database', err);
});

function getMigrations(): Migration[] {
  return [{
    id: 1,
    name: 'initial',
    statement: `
      CREATE TABLE accounts (
        id TEXT NOT NULL PRIMARY KEY,
        acct TEXT,
        username TEXT,
        display_name TEXT,
        url TEXT,
        avatar TEXT,
        avatar_static TEXT
      );
      CREATE TABLE tags (url TEXT NOT NULL PRIMARY KEY, tag TEXT NOT NULL);
      CREATE TABLE posts (
        id TEXT NOT NULL PRIMARY KEY,
        content TEXT,
        created_at TEXT,
        url TEXT NOT NULL,
        account_id TEXT NOT NULL,
        FOREIGN KEY (account_id) REFERENCES accounts(id)
      );
      CREATE TABLE poststags (
        id integer PRIMARY KEY,
        post_id TEXT NOT NULL,
        tag_url TEXT NOT NULL,
        FOREIGN KEY (post_id) REFERENCES posts(id),
        FOREIGN KEY (tag_url) REFERENCES tags(url)
      )`
  }];
}

export async function savePost(post: Post): Promise<undefined> {
  return new Promise((resolve, reject) => {
    console.debug(`Saving post ${post.url}`);
    const account = post.account;
    db.run(`
      INSERT INTO accounts (id, acct, username, display_name, url, avatar, avatar_static)
      VALUES(?, ?, ?, ?, ?, ?, ?)
      ON CONFLICT(id)
      DO UPDATE SET
      acct=excluded.acct,
      username=excluded.username,
      display_name=excluded.display_name,
      url=excluded.url,
      avatar=excluded.avatar,
      avatar_static=excluded.avatar_static;`,
      [
        account.id,
        account.acct,
        account.username,
        account.display_name,
        account.url,
        account.avatar,
        account.avatar_static
      ],
      (err) => {
        if (err !== null) {
          console.error(`Could not insert/update account ${account.id}`, err);
          reject(err);
          return;
        }
        db.run(`
          INSERT INTO posts (id, content, created_at, url, account_id)
          VALUES (?, ?, ?, ?, ?) ON CONFLICT(id) DO UPDATE SET
          content=excluded.content,
          created_at=excluded.created_at,
          url=excluded.url,
          account_id=excluded.account_id;`,
          [
            post.id,
            post.content,
            post.created_at,
            post.url,
            post.account.id
          ],
          (postErr) => {
            if (postErr !== null) {
              console.error(`Could not insert post ${post.url}`, postErr);
              reject(postErr);
              return;
            }

            db.parallelize(() => {
              let remaining = post.tags.length;
              for (let tag of post.tags) {
                db.run(`
                  INSERT INTO tags (url, tag) VALUES (?, ?)
                  ON CONFLICT(url) DO UPDATE SET
                  tag=excluded.tag;`,
                  [
                    tag.url,
                    tag.name
                  ],
                  (tagErr) => {
                    if (tagErr !== null) {
                      console.error(`Could not insert/update tag ${tag.url}`, tagErr);
                      reject(tagErr);
                      return;
                    }
                    db.run('INSERT INTO poststags (post_id, tag_url) VALUES (?, ?)',
                      [post.id, tag.url],
                      (posttagserr) => {
                        if (posttagserr !== null) {
                          console.error(`Could not insert poststags ${tag.url}, ${post.url}`, posttagserr);
                          reject(posttagserr);
                          return;
                        }
                        // Don't decrease on fail
                        remaining--;
                        // Only resolve after all have been inserted
                        if (remaining === 0) {
                          resolve(undefined);
                        }
                      }
                    );
                  }
                );
              }
            });
          });
      });
  });
}

export async function getPosts(since: string | null, before: string | null, limit: number) {
  let promise = await new Promise<Post[]>((resolve, reject) => {
    let filter_query;
    let params: any = { $limit: limit };
    if (since === null && before === null) {
      filter_query = '';
    } else if (since !== null) {
      filter_query = 'WHERE posts.created_at > $since';
      params.$since = since;
    } else if (before !== null) {
      // Setting both, before and since doesn't make sense, so this case is not explicitly handled
      filter_query = 'WHERE posts.created_at < $before';
      params.$before = before;
    }
    const sql = `SELECT posts.id, posts.content, posts.created_at, posts.url,
    accounts.id AS account_id, accounts.acct, accounts.username, accounts.display_name,
    accounts.url AS account_url, accounts.avatar
    FROM posts
    JOIN accounts ON posts.account_id = accounts.id
    ${filter_query}
    ORDER BY created_at DESC
    LIMIT $limit`;
    db.all(
      sql,
      params,
      (err, rows: any[]) => {
        if (err != null) {
          console.error('Error loading posts', err);
          reject(err);
          return;
        }
        if (rows.length === 0) {
          // No need to check for tags
          resolve([]);
          return;
        }
        const postIdsParams = rows.map(() => '?').join(', ');
        db.all(
          `SELECT post_id, tags.url, tags.tag
          FROM poststags
          JOIN tags ON poststags.tag_url = tags.url
          WHERE post_id IN (${postIdsParams});`,
          rows.map((r: any) => r.id),
          (tagErr, tagRows: any[]) => {
            if (tagErr != null) {
              console.error('Error loading post tags', tagErr);
              reject(tagErr);
              return;
            }
            const tagMap: Map<string, Tag[]> = tagRows.reduce(
              (result: Map<string, Tag[]>, item) => {
                const tag: Tag = {
                  url: item.url,
                  name: item.tag
                };
                result.set(item.post_id, [...result.get(item.post_id) || [], tag]);
                return result;
              }, new Map());
            const posts = rows.map(row => {
              return {
                id: row.id,
                content: row.content,
                created_at: row.created_at,
                url: row.url,
                tags: tagMap.get(row.id) || [],
                account: {
                  id: row.account_id,
                  acct: row.acct,
                  username: row.username,
                  display_name: row.display_name,
                  url: row.account_url,
                  avatar: row.avatar,
                  avatar_static: ''
                } as Account
              } as Post
            });
            resolve(posts);
          }
        );
      }
    );
  });
  return promise;
}