import fs from 'fs';
import yaml from 'js-yaml';
import assert from 'assert';
import { spawnSync } from 'child_process';

const TOKEN_TYPE = 'aphoton';

describe('Test laconic CLI commands', () => {
  test('laconic', async () => {
    const result = spawnSync('laconic');

    const output = result.stdout.toString().trim();
    const errorOutput = result.stderr.toString().trim();

    // Expect error with usage string
    expect(output).toBe('');
    expect(errorOutput).toContain('laconic <command>');
    expect(result.status).toBe(1);
  });

  test('laconic cns', async () => {
    const result = spawnSync('laconic', ['cns']);

    const output = result.stdout.toString().trim();
    const errorOutput = result.stderr.toString().trim();

    // Expect error with usage string
    expect(output).toBe('');
    expect(errorOutput).toContain('laconic cns');
    expect(errorOutput).toContain('CNS tools');
    expect(errorOutput).toContain('Commands:');
    expect(result.status).toBe(1);
  });

  describe('laconic CNS commands', () => {
    const initialAccountBalance = Number('100000000000000000000000000');
    // let accountSequence = 0;
    const existingAccount = process.env.EXISTING_ACCOUNT;
    assert(existingAccount, 'EXISTING_ACCOUNT not set in env');

    const secondAccount = 'ethm1vc62ysqu504at932jjq8pwrqgjt67rx6ggn5yu';


    test('laconic cns status', async () => {
      const result = spawnSync('laconic', ['cns', 'status']);

      const output = result.stdout.toString().trim();
      const outputObj = JSON.parse(output);
      const errorOutput = result.stderr.toString().trim();

      // Expect output object to have CNS status props
      expect(outputObj).toHaveProperty('version');
      expect(outputObj).toHaveProperty('node');
      expect(outputObj).toHaveProperty('node.network', 'laconic_9000-1');
      expect(outputObj).toHaveProperty('sync');
      expect(Number(outputObj.sync.latest_block_height)).toBeGreaterThan(0);
      expect(outputObj).toHaveProperty('validator');
      expect(outputObj).toHaveProperty('validators');
      expect(outputObj).toHaveProperty('num_peers');
      expect(outputObj).toHaveProperty('peers');
      expect(outputObj).toHaveProperty('disk_usage');

      expect(errorOutput).toBe('');
      expect(result.status).toBe(0);
    });

    describe('Bond operations', () => {
      const bondBalance = 1000000000;
      const bondOwner = existingAccount;
      let bondId: string;

      test('laconic cns bond create', async () => {
        const result = spawnSync('laconic', ['cns', 'bond', 'create', '--type', TOKEN_TYPE, '--quantity', bondBalance.toString(), '--gas', '200000', '--fees', `200000${TOKEN_TYPE}`]);
        // accountSequence++;

        const output = result.stdout.toString().trim();
        const errorOutput = result.stderr.toString().trim();

        expect(errorOutput).toBe('');
        expect(result.status).toBe(0);

        expect(output.length).toBeGreaterThan(0);
        const outputObj = JSON.parse(output);

        // Expect output object to have resultant bond id
        expect(outputObj).toHaveProperty('bondId');

        bondId = outputObj.bondId;
      });

      test('laconic cns bond list', async () => {
        const result = spawnSync('laconic', ['cns', 'bond', 'list']);

        const output = result.stdout.toString().trim();
        const errorOutput = result.stderr.toString().trim();

        expect(errorOutput).toBe('');
        expect(result.status).toBe(0);

        expect(output.length).toBeGreaterThan(0);
        const outputObj = Array.from<any>(JSON.parse(output));

        // Expected bond
        const expectedBond = getBond({ id: bondId, owner: bondOwner, balance: bondBalance });

        expect(outputObj.length).toEqual(1);
        expect(outputObj[0]).toEqual(expectedBond);
      });

      test('laconic cns bond list --owner <owner_address>', async () => {
        const result = spawnSync('laconic', ['cns', 'bond', 'list', '--owner', bondOwner]);

        const output = result.stdout.toString().trim();
        const errorOutput = result.stderr.toString().trim();

        expect(errorOutput).toBe('');
        expect(result.status).toBe(0);

        expect(output.length).toBeGreaterThan(0);
        const outputObj = Array.from<any>(JSON.parse(output));

        // Expected bond
        const expectedBond = getBond({ id: bondId, owner: bondOwner, balance: bondBalance });

        expect(outputObj.length).toEqual(1);
        expect(outputObj[0]).toEqual(expectedBond);
      });

      test('laconic cns bond get --id <bond_id>', async () => {
        const result = spawnSync('laconic', ['cns', 'bond', 'get', '--id', bondId]);

        const output = result.stdout.toString().trim();
        const errorOutput = result.stderr.toString().trim();

        expect(errorOutput).toBe('');
        expect(result.status).toBe(0);

        expect(output.length).toBeGreaterThan(0);
        const outputObj = Array.from<any>(JSON.parse(output));

        // Expected bond
        const expectedBond = getBond({ id: bondId, owner: bondOwner, balance: bondBalance });

        expect(outputObj.length).toEqual(1);
        expect(outputObj[0]).toEqual(expectedBond);
      });
    });

    describe('Account and tokens operations', () => {
      let balanceBeforeSend: number;

      test('laconic cns account get --address <account_address>', async () => {
        const result = spawnSync('laconic', ['cns', 'account', 'get', '--address', existingAccount]);

        const output = result.stdout.toString().trim();
        const errorOutput = result.stderr.toString().trim();

        expect(errorOutput).toBe('');
        expect(result.status).toBe(0);

        expect(output.length).toBeGreaterThan(0);
        const outputObj = Array.from<any>(JSON.parse(output));

        // Expected account
        const expectedAccount = {
          address: existingAccount,
          number: 0,
          sequence: 2,
          balance: [
            {
              type: TOKEN_TYPE
            }
          ]
        };
        balanceBeforeSend = Number(outputObj[0].balance[0].quantity);

        expect(outputObj.length).toEqual(1);
        expect(outputObj[0]).toMatchObject(expectedAccount);
        expect(balanceBeforeSend).toBeGreaterThan(0);
        expect(balanceBeforeSend).toBeLessThan(initialAccountBalance);
      });

      test('laconic cns tokens send --address <account_address> --type <token_type> --quantity <quantity>', async () => {
        const sendAmount = 1000000000;
        const balanceAfterSend = balanceBeforeSend - sendAmount;

        const result = spawnSync('laconic', ['cns', 'tokens', 'send', '--address', secondAccount, '--type', TOKEN_TYPE, '--quantity', sendAmount.toString()]);
        // accountSequence++;

        const output = result.stdout.toString().trim();
        const errorOutput = result.stderr.toString().trim();

        expect(errorOutput).toBe('');
        expect(result.status).toBe(0);

        expect(output.length).toBeGreaterThan(0);
        const outputObj = Array.from<any>(JSON.parse(output));

        // Expected acconts
        const expectedAccounts = [
          {
            address: existingAccount,
            number: 0,
            sequence: 3,
            balance: [
              {
                type: TOKEN_TYPE,
                quantity: balanceAfterSend
              }
            ]
          },
          {
            address: secondAccount,
            pubKey: null,
            sequence: 0,
            balance: [
              {
                type: TOKEN_TYPE,
                quantity: sendAmount
              }
            ]
          },
        ];

        expect(outputObj.length).toEqual(2);
        expect(outputObj).toMatchObject(expectedAccounts);
      });
    });

    describe('Record operations', () => {
      const recordFilePath = 'test/data/watcher-record.yml';
      const gas = 250000;
      const bondBalance = 1000000000;
      const { bondId } = createBond(bondBalance);
      let recordId: string;

      test('laconic cns record publish --filename <record_file> --bond-id <bond_id> --gas <gas>', async () => {
        const result = spawnSync('laconic', ['cns', 'record', 'publish', '--filename', recordFilePath, '--bond-id', bondId, '--gas', gas.toString()]);

        const output = result.stdout.toString().trim();
        const errorOutput = result.stderr.toString().trim();

        expect(errorOutput).toBe('');
        expect(result.status).toBe(0);

        expect(output.length).toBeGreaterThan(0);
        const outputObj = JSON.parse(output);

        // Expect output object to resultant bond id
        expect(outputObj).toHaveProperty('id');

        recordId = outputObj.id;
      });

      test('laconic cns record list', async () => {
        const result = spawnSync('laconic', ['cns', 'record', 'list']);

        const output = result.stdout.toString().trim();
        const errorOutput = result.stderr.toString().trim();

        expect(errorOutput).toBe('');
        expect(result.status).toBe(0);

        expect(output.length).toBeGreaterThan(0);
        const outputObj = Array.from<any>(JSON.parse(output));

        // Expected record
        const expectedRecord = getRecord(recordFilePath, { bondId, recordId });

        expect(outputObj.length).toEqual(1);
        expect(outputObj[0]).toMatchObject(expectedRecord);
        expect(outputObj[0]).toHaveProperty('createTime');
        expect(outputObj[0]).toHaveProperty('expiryTime');
        expect(outputObj[0]).toHaveProperty('owners');
        expect(outputObj[0].owners.length).toEqual(1);
      });

      test('laconic cns record get --id <record_id>', async () => {
        const result = spawnSync('laconic', ['cns', 'record', 'get', '--id', recordId]);

        const output = result.stdout.toString().trim();
        const errorOutput = result.stderr.toString().trim();

        expect(errorOutput).toBe('');
        expect(result.status).toBe(0);

        expect(output.length).toBeGreaterThan(0);
        const outputObj = Array.from<any>(JSON.parse(output));

        // Expected record
        const expectedRecord = getRecord(recordFilePath, { bondId, recordId });

        expect(outputObj.length).toEqual(1);
        expect(outputObj[0]).toMatchObject(expectedRecord);
      });
    });

    describe('Name authority operations', () => {
      const authorityName = 'laconic';

      test('laconic cns authority reserve <authority_name>', async () => {
        const result = spawnSync('laconic', ['cns', 'authority', 'reserve', authorityName]);

        const output = result.stdout.toString().trim();
        const errorOutput = result.stderr.toString().trim();

        expect(errorOutput).toBe('');
        expect(result.status).toBe(0);

        expect(output.length).toBeGreaterThan(0);
        const outputObj = JSON.parse(output);

        // Expect result
        expect(outputObj).toEqual({ success: true });
      });

      test('laconic cns authority whois <authority_name>', async () => {
        const result = spawnSync('laconic', ['cns', 'authority', 'whois', authorityName]);

        const output = result.stdout.toString().trim();
        const errorOutput = result.stderr.toString().trim();

        expect(errorOutput).toBe('');
        expect(result.status).toBe(0);

        expect(output.length).toBeGreaterThan(0);
        const outputObj = Array.from<any>(JSON.parse(output));

        // Expected authority (still in auction)
        const expectedAuthority = getAuthority({ status: 'auction', auction: getAuction({ owner: existingAccount }) });

        expect(outputObj.length).toEqual(1);
        expect(outputObj[0]).toMatchObject(expectedAuthority);
        expect(outputObj[0]).toHaveProperty('expiryTime');
        expect(outputObj[0].height).toBeGreaterThan(0);
      });
    });
  });
});

// Helper methods

function getBond(params: { id: string, owner: string, balance: number}): any {
  return {
    id: params.id,
    owner: params.owner,
    balance: [
      {
        type: TOKEN_TYPE,
        quantity: params.balance
      }
    ]
  };
}

function createBond(quantity: number): { bondId: string } {
  const result = spawnSync('laconic', ['cns', 'bond', 'create', '--type', TOKEN_TYPE, '--quantity', quantity.toString(), '--gas', '200000', '--fees', `200000${TOKEN_TYPE}`]);
  const output = result.stdout.toString().trim();

  return JSON.parse(output);
}

function getRecord(recordFilePath: string, params: { bondId: string, recordId: string }): any {
  const recordContent = yaml.load(fs.readFileSync(recordFilePath, 'utf8')) as any;

  return {
    id: params.recordId,
    names: null,
    bondId: params.bondId,
    attributes: recordContent.record
  };
}

function getAuthority(params: { status: string, auction: any }): any {
  return {
    ownerAddress: '',
    ownerPublicKey: '',
    status: params.status,
    bondId: '',
    auction: params.auction || null
  };
}

function getAuction(params: { owner: string, status?: string, bids?: any[] }): any {
  const auctionFees = {
    commit: 1000000,
    reveal: 1000000,
    minimumBid: 5000000
  };

  return {
    status: params.status || 'commit',
    ownerAddress: params.owner,
    commitFee: {
      type: TOKEN_TYPE,
      quantity: auctionFees.commit
    },
    revealFee: {
      type: TOKEN_TYPE,
      quantity: auctionFees.reveal
    },
    minimumBid: {
      type: TOKEN_TYPE,
      quantity: auctionFees.minimumBid
    },
    winnerAddress: '',
    bids: params.bids || []
  };
}