import { MigrationInterface, QueryRunner, Table, TableColumn } from 'typeorm'
import { PrivateKey } from '..'
import { PreMigrationKey } from '../entities/PreMigrationEntities'
import Debug from 'debug'
const debug = Debug('verixyz:data-store:migrate-private-keys')

/**
 * Migration of existing private keys from verixyz 2.x to verixyz 3.x
 */
export class CreatePrivateKeyStorage1629293428674 implements MigrationInterface {
  async up(queryRunner: QueryRunner): Promise<void> {
    function getTableName(givenName: string): string {
      return (
        queryRunner.connection.entityMetadatas.find((meta) => meta.givenTableName === givenName)?.tableName ||
        givenName
      )
    }
    // 1.create new table
    debug(`creating new private-key table`)
    await queryRunner.createTable(
      new Table({
        name: getTableName('private-key'),
        columns: [
          {
            name: 'alias',
            type: 'varchar',
            isPrimary: true,
          },
          {
            name: 'type',
            type: 'varchar',
          },
          {
            name: 'privateKeyHex',
            type: 'varchar',
          },
        ],
      }),
      true,
    )
    // 2. copy key data
    const keys: PreMigrationKey[] = await queryRunner.manager.find(PreMigrationKey)
    debug(`got ${keys.length} potential keys to migrate`)
    const privKeys = keys
      .filter((key) => typeof key.privateKeyHex !== 'undefined' && key.privateKeyHex !== null)
      .map((key) => ({
        alias: key.kid,
        type: key.type,
        privateKeyHex: key.privateKeyHex,
      }))
    debug(`${privKeys.length} keys need to be migrated`)
    await queryRunner.manager
      .createQueryBuilder()
      .insert()
      .into(getTableName('private-key'))
      .values(privKeys)
      .execute()
    // 3. drop old column
    debug(`dropping privKeyHex column from old key table`)
    await queryRunner.dropColumn(getTableName('key'), 'privateKeyHex')
    //4. done
    debug(`migrated ${privKeys.length} keys to private key storage`)
  }

  async down(queryRunner: QueryRunner): Promise<void> {
    function getTableName(givenName: string): string {
      return (
        queryRunner.connection.entityMetadatas.find((meta) => meta.givenTableName === givenName)?.tableName ||
        givenName
      )
    }
    // 1. add old column back
    debug(`adding back privateKeyHex column to key table`)
    await queryRunner.addColumn(
      'key',
      new TableColumn({
        name: 'privateKeyHex',
        type: 'varchar',
        isNullable: true,
      }),
    )
    // 2. copy key data
    debug(`checking keys to be rolled back`)
    const keys: PrivateKey[] = await queryRunner.manager.find(PrivateKey)
    debug(`copying ${keys.length} keys`)
    for (const key of keys) {
      await queryRunner.manager
        .createQueryBuilder()
        .update(PreMigrationKey)
        .set({ privateKeyHex: key.privateKeyHex })
        .where('kid = :alias', { alias: key.alias })
        .execute()
    }
    debug(`dropping private-key table`)
    // 3. drop the new private key table
    await queryRunner.dropTable(getTableName('private-key'))
    // 4. done
    debug(`rolled back ${keys.length} keys`)
  }
}