import { bench, describe } from 'vitest';
import { QUICK } from '../helpers/bench-options.js';
import {
  ok,
  err,
  some,
  none,
  okSome,
  okNone,
  errNone,
  ntOk,
  ntErr,
  TsOk,
  TsErr,
  TsSome,
  TsNone,
  OxOk,
  OxErr,
  OxSome,
  OxNone,
  E,
  O,
  TmResult,
  TmMaybe,
} from '../helpers/imports.js';

// ---------------------------------------------------------------------------
// Singleton reuse: None / OkNone
// ---------------------------------------------------------------------------

describe('Memory: 1000x None creation (singleton vs constructor)', () => {
  bench('native-monad none() — frozen singleton', () => {
    for (let i = 0; i < 1000; i++) none();
  }, QUICK);

  bench('ts-results-es None — constant', () => {
    for (let i = 0; i < 1000; i++) { const _ = TsNone; }
  }, QUICK);

  bench('oxide.ts None — constant', () => {
    for (let i = 0; i < 1000; i++) { const _ = OxNone; }
  }, QUICK);

  bench('fp-ts O.none — constant', () => {
    for (let i = 0; i < 1000; i++) { const _ = O.none; }
  }, QUICK);

  bench('true-myth Maybe.nothing() — constructor', () => {
    for (let i = 0; i < 1000; i++) TmMaybe.nothing();
  }, QUICK);
});

describe('Memory: 1000x OkNone creation', () => {
  bench('native-monad okNone() — frozen singleton', () => {
    for (let i = 0; i < 1000; i++) okNone();
  }, QUICK);

  bench('fp-ts E.right(O.none) — two allocations', () => {
    for (let i = 0; i < 1000; i++) E.right(O.none);
  }, QUICK);
});

// ---------------------------------------------------------------------------
// Constructor allocation: Ok / Some / OkSome
// ---------------------------------------------------------------------------

describe('Memory: 1000x Ok construction', () => {
  bench('native-monad ok(i) — class instance', () => {
    for (let i = 0; i < 1000; i++) ok(i);
  }, QUICK);

  bench('neverthrow ok(i) — class instance', () => {
    for (let i = 0; i < 1000; i++) ntOk(i);
  }, QUICK);

  bench('ts-results-es Ok(i) — class instance', () => {
    for (let i = 0; i < 1000; i++) TsOk(i);
  }, QUICK);

  bench('oxide.ts Ok(i) — tagged object', () => {
    for (let i = 0; i < 1000; i++) OxOk(i);
  }, QUICK);

  bench('fp-ts E.right(i) — tagged object', () => {
    for (let i = 0; i < 1000; i++) E.right(i);
  }, QUICK);

  bench('true-myth Result.ok(i) — class instance', () => {
    for (let i = 0; i < 1000; i++) TmResult.ok(i);
  }, QUICK);
});

describe('Memory: 1000x Some construction', () => {
  bench('native-monad some(i)', () => {
    for (let i = 0; i < 1000; i++) some(i);
  }, QUICK);

  bench('ts-results-es Some(i)', () => {
    for (let i = 0; i < 1000; i++) TsSome(i);
  }, QUICK);

  bench('oxide.ts Some(i)', () => {
    for (let i = 0; i < 1000; i++) OxSome(i);
  }, QUICK);

  bench('fp-ts O.some(i)', () => {
    for (let i = 0; i < 1000; i++) O.some(i);
  }, QUICK);

  bench('true-myth Maybe.just(i)', () => {
    for (let i = 0; i < 1000; i++) TmMaybe.just(i);
  }, QUICK);
});

describe('Memory: 1000x Err construction', () => {
  bench('native-monad err(i)', () => {
    for (let i = 0; i < 1000; i++) err(`err-${i}`);
  }, QUICK);

  bench('neverthrow err(i)', () => {
    for (let i = 0; i < 1000; i++) ntErr(`err-${i}`);
  }, QUICK);

  bench('ts-results-es Err(i)', () => {
    for (let i = 0; i < 1000; i++) TsErr(`err-${i}`);
  }, QUICK);

  bench('oxide.ts Err(i)', () => {
    for (let i = 0; i < 1000; i++) OxErr(`err-${i}`);
  }, QUICK);

  bench('fp-ts E.left(i)', () => {
    for (let i = 0; i < 1000; i++) E.left(`err-${i}`);
  }, QUICK);

  bench('true-myth Result.err(i)', () => {
    for (let i = 0; i < 1000; i++) TmResult.err(`err-${i}`);
  }, QUICK);
});

// ---------------------------------------------------------------------------
// Three-state: OkSome vs nested allocation
// ---------------------------------------------------------------------------

describe('Memory: 1000x OkSome (single vs nested allocation)', () => {
  bench('native-monad okSome(i) — single class', () => {
    for (let i = 0; i < 1000; i++) okSome(i);
  }, QUICK);

  bench('fp-ts E.right(O.some(i)) — two objects', () => {
    for (let i = 0; i < 1000; i++) E.right(O.some(i));
  }, QUICK);

  bench('ts-results-es Ok(Some(i)) — two classes', () => {
    for (let i = 0; i < 1000; i++) TsOk(TsSome(i));
  }, QUICK);
});

describe('Memory: 1000x ErrNone (single vs nested allocation)', () => {
  bench('native-monad errNone(i) — single class', () => {
    for (let i = 0; i < 1000; i++) errNone(`err-${i}`);
  }, QUICK);

  bench('fp-ts E.left(i) — single object', () => {
    for (let i = 0; i < 1000; i++) E.left(`err-${i}`);
  }, QUICK);

  bench('ts-results-es Err(i) — single class', () => {
    for (let i = 0; i < 1000; i++) TsErr(`err-${i}`);
  }, QUICK);
});