<?php

declare(strict_types=1);

namespace Psl\Tests\Collection;

use PHPUnit\Framework\TestCase;
use Psl\Collection;
use Psl\Exception;
use Psl\Iter;
use Psl\Str;

class MapTest extends TestCase
{
    public function testAdd(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2]);
        self::assertCount(2, $map);

        $map->add(new Collection\Pair('baz', 3));
        self::assertCount(3, $map);
        self::assertTrue($map->contains('baz'));

        $map->add(new Collection\Pair('qux', 4));
        self::assertCount(4, $map);
        self::assertTrue($map->contains('qux'));
    }

    public function testAddAll(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2]);
        self::assertCount(2, $map);

        $map->addAll([
            new Collection\Pair('baz', 3),
            new Collection\Pair('qux', 4)
        ]);

        self::assertCount(4, $map);
        self::assertTrue($map->contains('baz'));
        self::assertTrue($map->contains('qux'));
    }

    public function testClear(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2]);
        $map->clear();

        self::assertCount(0, $map);

        $map = new Collection\Map([]);
        $map->clear();
        self::assertCount(0, $map);
    }

    public function testItems(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2]);

        $items = $map->items();

        self::assertSame(2, $items->count());

        self::assertSame('foo', $items->at(0)->first());
        self::assertSame(1, $items->at(0)->last());

        self::assertSame('bar', $items->at(1)->first());
        self::assertSame(2, $items->at(1)->last());
    }

    public function testIsEmpty(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2]);

        self::assertFalse($map->isEmpty());

        $map = $map->filter(fn ($v) => false);

        self::assertTrue($map->isEmpty());
    }

    public function testCount(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2]);
        self::assertCount(2, $map);

        $map = $map->filter(fn ($v) => 1 === $v);
        self::assertCount(1, $map);

        $map = $map->filter(fn ($v) => false);
        self::assertCount(0, $map);
    }

    public function testToArray(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2]);
        $array = $map->toArray();

        self::assertArrayHasKey('foo', $array);
        self::assertArrayHasKey('bar', $array);

        self::assertSame(1, $array['foo']);
        self::assertSame(2, $array['bar']);

        $map = $map->filter(fn ($v) => false);
        $array = $map->toArray();

        self::assertEmpty($array);
    }

    public function testAt(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2]);

        self::assertSame(1, $map->at('foo'));
        self::assertSame(2, $map->at('bar'));

        $this->expectException(Exception\InvariantViolationException::class);
        $this->expectExceptionMessage('Key (baz) is out-of-bound.');

        $map->at('baz');
    }

    public function testContainsKey(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2, 'baz' => null]);

        self::assertTrue($map->containsKey('foo'));
        self::assertTrue($map->containsKey('bar'));
        self::assertTrue($map->containsKey('baz'));
        self::assertFalse($map->containsKey('qux'));
    }

    public function testGet(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2]);

        self::assertSame(1, $map->get('foo'));
        self::assertSame(2, $map->get('bar'));
        self::assertNull($map->get('baz'));
    }

    public function testContains(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2, 'baz' => null]);

        self::assertTrue($map->contains('foo'));
        self::assertTrue($map->contains('bar'));
        self::assertTrue($map->contains('baz'));
        self::assertFalse($map->contains('qux'));
    }

    public function testValues(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2, 'baz' => null]);
        $values = $map->values();

        self::assertCount(3, $values);
        self::assertSame(1, $values->at(0));
        self::assertSame(2, $values->at(1));
        self::assertNull($values->at(2));
    }

    public function testKeys(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2, 'baz' => null]);
        $keys = $map->keys();

        self::assertCount(3, $keys);
        self::assertSame('foo', $keys->at(0));
        self::assertSame('bar', $keys->at(1));
        self::assertSame('baz', $keys->at(2));
    }

    public function testMap(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2, 'baz' => 3]);

        $map = $map->map(fn ($value) => $value * 2);
        self::assertSame(2, $map->at('foo'));
        self::assertSame(4, $map->at('bar'));
        self::assertSame(6, $map->at('baz'));
    }

    public function testMapWithKey(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2, 'baz' => 3]);

        $map = $map->mapWithKey(fn ($key, $value) => Str\format('%s (%d)', $key, $value));
        self::assertSame('foo (1)', $map->at('foo'));
        self::assertSame('bar (2)', $map->at('bar'));
        self::assertSame('baz (3)', $map->at('baz'));
    }

    public function testFilter(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2, 'baz' => 3]);

        $map = $map->filter(fn ($value) => $value >= 2);
        self::assertCount(2, $map);

        self::assertFalse($map->contains('foo'));
        self::assertTrue($map->contains('bar'));
        self::assertTrue($map->contains('baz'));
    }

    public function testFilterWithKey(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2, 'baz' => 3]);

        $map = $map->filterWithKey(fn ($key, $value) => $value >= 2 && 'baz' !== $key);
        self::assertCount(1, $map);

        self::assertFalse($map->contains('foo'));
        self::assertTrue($map->contains('bar'));
        self::assertFalse($map->contains('baz'));
    }

    public function testZip(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2, 'baz' => 3, 'qux' => 4]);

        $map = $map->zip(['one', 'two', 'three']);

        /** @var Collection\Pair $foo */
        $foo = $map->at('foo');
        self::assertInstanceOf(Collection\Pair::class, $foo);
        self::assertSame(1, $foo->first());
        self::assertSame('one', $foo->last());

        /** @var Collection\Pair $bar */
        $bar = $map->at('bar');
        self::assertInstanceOf(Collection\Pair::class, $bar);
        self::assertSame(2, $bar->first());
        self::assertSame('two', $bar->last());

        /** @var Collection\Pair $baz */
        $baz = $map->at('baz');
        self::assertInstanceOf(Collection\Pair::class, $baz);
        self::assertSame(3, $baz->first());
        self::assertSame('three', $baz->last());
    }

    public function testTake(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2, 'baz' => 3]);

        $map = $map->take(2);

        self::assertCount(2, $map);
        self::assertTrue($map->contains('foo'));
        self::assertTrue($map->contains('bar'));
        self::assertFalse($map->contains('baz'));
    }

    public function testTakeWhile(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2, 'baz' => 3]);

        $map = $map->takeWhile(fn ($v) => 2 !== $v);

        self::assertCount(1, $map);
        self::assertTrue($map->contains('foo'));
        self::assertFalse($map->contains('bar'));
        self::assertFalse($map->contains('baz'));
    }

    public function testDrop(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2, 'baz' => 3]);

        $map = $map->drop(1);

        self::assertCount(2, $map);
        self::assertFalse($map->contains('foo'));
        self::assertTrue($map->contains('bar'));
        self::assertTrue($map->contains('baz'));
    }

    public function testDropWhile(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2, 'baz' => 3]);

        $map = $map->dropWhile(fn ($value) => 3 !== $value);

        self::assertCount(1, $map);
        self::assertFalse($map->contains('foo'));
        self::assertFalse($map->contains('bar'));
        self::assertTrue($map->contains('baz'));
    }

    public function testSlice(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2, 'baz' => 3, 'qux' => 4]);

        $map = $map->slice(2, 1);

        self::assertCount(1, $map);
        self::assertFalse($map->contains('foo'));
        self::assertFalse($map->contains('bar'));
        self::assertTrue($map->contains('baz'));
        self::assertFalse($map->contains('qux'));

        $map = $map->slice(0, 0);

        self::assertCount(0, $map);
    }

    public function testConcat(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2, 'baz' => 3, 'qux' => 4]);
        $vector = $map->concat([5, 6, 7, 8, 9, 10]);

        self::assertCount(10, $vector);
        self::assertSame([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], $vector->toArray());
    }

    public function testFirst(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2, 'baz' => 3, 'qux' => 4]);

        self::assertSame(1, $map->first());

        $map = new Collection\Map([]);

        self::assertNull($map->first());
    }

    public function testFirstKey(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2, 'baz' => 3, 'qux' => 4]);

        self::assertSame('foo', $map->firstKey());

        $map = new Collection\Map([]);

        self::assertNull($map->firstKey());
    }

    public function testLast(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2, 'baz' => 3, 'qux' => 4]);

        self::assertSame(4, $map->last());

        $map = new Collection\Map([]);

        self::assertNull($map->last());
    }

    public function testLastKey(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2, 'baz' => 3, 'qux' => 4]);

        self::assertSame('qux', $map->lastKey());

        $map = new Collection\Map([]);

        self::assertNull($map->lastKey());
    }

    public function testDifferenceByKey(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2, 'baz' => 3, 'qux' => 4]);

        $map = $map->differenceByKey(['foo' => 5, 'baz' => 6]);

        self::assertFalse($map->contains('foo'));
        self::assertTrue($map->contains('bar'));
        self::assertFalse($map->contains('baz'));
        self::assertTrue($map->contains('qux'));
    }

    public function testImmutable(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2, 'baz' => 3, 'qux' => 4]);
        $immutable = $map->immutable();

        self::assertSame($map->toArray(), $immutable->toArray());
    }

    public function testGetIterator(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2, 'baz' => 3, 'qux' => 4]);

        $iterator = $map->getIterator();
        self::assertInstanceOf(Iter\Iterator::class, $iterator);

        $array = \iterator_to_array($iterator);
        self::assertSame(['foo' => 1, 'bar' => 2, 'baz' => 3, 'qux' => 4], $array);
    }

    public function testRemove(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2, 'baz' => 3, 'qux' => 4]);

        $map->remove('foo');

        self::assertFalse($map->contains('foo'));
    }

    public function testSet(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2, 'baz' => 3]);

        $map->set('foo', 5);

        self::assertSame(5, $map->get('foo'));

        $map->set('qux', 4);
        self::assertTrue($map->contains('qux'));
        self::assertSame(4, $map->get('qux'));
    }

    public function testSetAll(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2, 'baz' => 3]);

        $map->setAll(['foo' => 5, 'qux' => 4]);

        self::assertSame(5, $map->get('foo'));
        self::assertTrue($map->contains('qux'));
        self::assertSame(4, $map->get('qux'));
    }

    public function testRemoveKey(): void
    {
        $map = new Collection\Map(['foo' => 1, 'bar' => 2, 'baz' => 3, 'qux' => 4]);

        $map->removeKey('foo');

        self::assertFalse($map->contains('foo'));
    }
}