import { Connection, Keypair, PublicKey } from '@solana/web3.js';
import { BN } from '@staratlas/anchor';
import { CargoPod } from '@staratlas/cargo';
import {
  DecodedAccountData,
  InstructionReturn,
  createAssociatedTokenAccountIdempotent,
  keypairToAsyncSigner,
  readFromRPCOrError,
} from '@staratlas/data-source';
import { chunk } from 'lodash';
import {
  StarbasePlayer,
  cleanUpStarbaseCargoPods,
  divideIntoParts,
  getCargoPodsByAuthority,
} from '../src';
import { SageGameTest } from './helpers';

describe('Utilities', () => {
  const connection = new Connection('http://localhost:8899', 'confirmed');
  const walletKeypair = Keypair.generate();
  const walletSigner = keypairToAsyncSigner(walletKeypair);

  let sageGameTest: SageGameTest;

  beforeAll(async () => {
    const airdropTx = await connection.requestAirdrop(
      walletSigner.publicKey(),
      500_000_000_000,
    );
    await connection.confirmTransaction(airdropTx);
    sageGameTest = await SageGameTest.createGame({
      funder: walletKeypair,
      connection,
    });
  });

  it('can run `cleanUpStarbaseCargoPods`', async () => {
    if (
      !sageGameTest.mints ||
      !sageGameTest.sectors ||
      !sageGameTest.cargoStatsDefinition ||
      !sageGameTest.gameState
    ) {
      throw 'test environment not ready';
    }

    // create new Sectors
    await sageGameTest.createSector({
      coordinates: [new BN(-3), new BN(-3)],
      numCrewForPlayer: 3,
    });
    await sageGameTest.createSector({
      coordinates: [new BN(3), new BN(3)],
      numCrewForPlayer: 3,
    });

    // create dirty cargo pods
    const sbpTestObjects = sageGameTest.sectors
      .map((it) => it.starbasePlayers)
      .flat();
    for (let index = 0; index < sbpTestObjects.length; index++) {
      const sbpElement = sbpTestObjects[index];
      const sbpAccount = await readFromRPCOrError(
        sageGameTest.connection,
        sageGameTest.program,
        sbpElement.starbasePlayer,
        StarbasePlayer,
      );
      const cargoPods: PublicKey[] = [];
      const createPodsIx: InstructionReturn[] = [];
      const numExtraPods = 3;
      for (let podCreateIdx = 0; podCreateIdx < numExtraPods; podCreateIdx++) {
        const podSeeds = Keypair.generate().publicKey.toBuffer();
        const cargoPod = CargoPod.findAddress(
          sageGameTest.cargoProgram,
          Buffer.from(podSeeds),
        )[0];
        cargoPods.push(cargoPod);
        const podIx = StarbasePlayer.createCargoPod(
          sageGameTest.program,
          sageGameTest.cargoProgram,
          sbpAccount.key,
          sageGameTest.profiles.player1.key,
          sageGameTest.profiles.player1.profile,
          sageGameTest.getProfileFactionAddress(
            sageGameTest.profiles.player1.profile,
          ),
          sbpAccount.data.starbase,
          sageGameTest.cargoStatsDefinition,
          sageGameTest.gameId,
          sageGameTest.gameState,
          {
            keyIndex: sageGameTest.profiles.player1.index,
            podSeeds: Array.from(podSeeds),
          },
        );
        createPodsIx.push(podIx);
      }
      await sageGameTest.sendToChain(createPodsIx);

      for (let index = 0; index < cargoPods.length; index++) {
        const depositCargoIx: InstructionReturn[] = [];
        const cargoPod = cargoPods[index];
        // deposit some cargo
        depositCargoIx.push(
          ...sageGameTest.addCargoToGameInstructions(
            sbpAccount.data.starbase,
            sbpAccount.key,
            sageGameTest.mints[SageGameTest.REPAIR_KIT],
            1337,
            cargoPod,
          ),
        );
        // create empty token account which has a cargo type
        const sduATA = createAssociatedTokenAccountIdempotent(
          sageGameTest.mints[SageGameTest.SDU],
          cargoPod,
          true,
        );
        depositCargoIx.push(sduATA.instructions);
        // create empty token account which does not have a cargo type
        const polisATA = await createAssociatedTokenAccountIdempotent(
          sageGameTest.mints[SageGameTest.POLIS],
          cargoPod,
          true,
        );
        depositCargoIx.push(polisATA.instructions);
        await sageGameTest.sendToChain(depositCargoIx);
      }
    }

    const cargoPodsBefore: DecodedAccountData<CargoPod>[] = [];
    for (let podsB4Idx = 0; podsB4Idx < sbpTestObjects.length; podsB4Idx++) {
      const element = sbpTestObjects[podsB4Idx];
      cargoPodsBefore.push(
        ...(await getCargoPodsByAuthority(
          sageGameTest.connection,
          sageGameTest.cargoProgram,
          element.starbasePlayer,
        )),
      );
    }
    expect(cargoPodsBefore.length).toBe(12);

    // clean up
    const cleanUpIx = await cleanUpStarbaseCargoPods(
      sageGameTest.connection,
      sageGameTest.program,
      sageGameTest.cargoProgram,
      sageGameTest.profiles.player1.profile,
      sageGameTest.getProfileFactionAddress(
        sageGameTest.profiles.player1.profile,
      ),
      sageGameTest.cargoStatsDefinition,
      sageGameTest.gameId,
      sageGameTest.gameState,
      sageGameTest.profiles.player1.key,
      sageGameTest.profiles.player1.index,
    );
    const cleaningChunks = chunk(cleanUpIx, 4);
    for (let index = 0; index < cleaningChunks.length; index++) {
      await sageGameTest.sendToChain(cleaningChunks[index]);
    }

    const cargoPodsAfter: DecodedAccountData<CargoPod>[] = [];
    for (let podsAftIdx = 0; podsAftIdx < sbpTestObjects.length; podsAftIdx++) {
      const element = sbpTestObjects[podsAftIdx];
      cargoPodsAfter.push(
        ...(await getCargoPodsByAuthority(
          sageGameTest.connection,
          sageGameTest.cargoProgram,
          element.starbasePlayer,
        )),
      );
    }

    expect(cargoPodsAfter.length).toBe(3);
  });

  it('can run divideIntoParts', () => {
    expect(divideIntoParts(20, 2)).toEqual([10, 10]);

    expect(divideIntoParts(7, 2)).toEqual([4, 3]);

    expect(divideIntoParts(3, 5)).toEqual([1, 1, 1, 0, 0]);

    expect(divideIntoParts(10, 1)).toEqual([10]);

    expect(divideIntoParts(5, 5)).toEqual([1, 1, 1, 1, 1]);

    expect(divideIntoParts(10, 0)).toEqual([]);

    expect(divideIntoParts(0, 3)).toEqual([0, 0, 0]);

    expect(divideIntoParts(32, Math.ceil(32 / 5))).toEqual([
      5, 5, 5, 5, 4, 4, 4,
    ]);
  });
});