<?php

use Gregwar\Image\Image;
use Gregwar\Image\ImageColor;

if (class_exists('\PHPUnit\Framework\TestCase')) {
    class Base extends \PHPUnit\Framework\TestCase
    {
    }
} else {
    class Base extends \PHPUnit_Framework_TestCase
    {
    }
}

/**
 * Unit testing for Image.
 */
class ImageTests extends Base
{
    /**
     * Testing the basic width & height.
     */
    public function testBasics()
    {
        $image = $this->open('monalisa.jpg');

        $this->assertSame($image->width(), 771);
        $this->assertSame($image->height(), 961);
    }

    /**
     * Testing the resize.
     */
    public function testResize()
    {
        $image = $this->open('monalisa.jpg');

        $out = $this->output('monalisa_small.jpg');
        $image
            ->resize(300, 200)
            ->save($out)
            ;

        $this->assertTrue(file_exists($out));

        $i = imagecreatefromjpeg($out);
        $this->assertSame(300, imagesx($i));
        $this->assertSame(200, imagesy($i));
    }

    /**
     * Testing the resize %.
     */
    public function testResizePercent()
    {
        $image = $this->open('monalisa.jpg');

        $out = $this->output('monalisa_small.jpg');
        $image
            ->resize('50%')
            ->save($out)
            ;

        $this->assertTrue(file_exists($out));

        $i = imagecreatefromjpeg($out);
        $this->assertSame(386, imagesx($i));
        $this->assertSame(481, imagesy($i));
    }

    /**
     * Testing to create an image, jpeg, gif and png.
     */
    public function testCreateImage()
    {
        $black = $this->output('black.jpg');

        Image::create(150, 200)
            ->fill('black')
            ->save($black, 100);

        $i = imagecreatefromjpeg($black);
        $this->assertTrue(file_exists($black));
        $this->assertSame(150, imagesx($i));
        $this->assertSame(200, imagesy($i));

        $j = imagecolorat($i, 40, 40);
        $this->assertSame(0, $j);

        $black = $this->output('black.png');
        Image::create(150, 200)
            ->fill('black')
            ->save($black, 'png');

        $i = imagecreatefrompng($black);
        $this->assertTrue(file_exists($black));
        $this->assertSame(150, imagesx($i));
        $this->assertSame(200, imagesy($i));

        $black = $this->output('black.gif');
        Image::create(150, 200)
            ->fill('black')
            ->save($black, 'gif');

        $i = imagecreatefromgif($black);
        $this->assertTrue(file_exists($black));
        $this->assertSame(150, imagesx($i));
        $this->assertSame(200, imagesy($i));
    }

    /**
     * Testing type guess.
     */
    public function testGuess()
    {
        $image = $this->open('monalisa.jpg');
        $this->assertSame('jpeg', $image->guessType());
        $image = $this->open('monalisa.png');
        $this->assertSame('png', $image->guessType());
        $image = $this->open('monalisa.gif');
        $this->assertSame('gif', $image->guessType());
    }

    public function testDefaultCacheSystem()
    {
        $image = $this->open('monalisa.jpg');
        $this->assertInstanceOf('Gregwar\Cache\Cache', $image->getCacheSystem());
    }

    public function testCustomCacheSystem()
    {
        $image = $this->open('monalisa.jpg');
        $cache = $this->getMock('Gregwar\Cache\CacheInterface');
        $image->setCacheSystem($cache);
        $this->assertTrue($image->getCacheSystem() instanceof Gregwar\Cache\CacheInterface);
    }

    /**
     * Testing that caching an image without operations will result
     * in the original image when force cache is disabled.
     */
    public function testNoCache()
    {
        $monalisa = __DIR__.'/files/monalisa.jpg';
        $image = $this->open('monalisa.jpg')->setForceCache(false);
        $this->assertSame($monalisa, $image->guess());
        $image = $this->open('monalisa.jpg');
        $this->assertNotSame($monalisa, $image->guess());
        $image = $this->open('monalisa.jpg')->setForceCache(true);
        $this->assertNotSame($monalisa, $image->guess());
    }

    public function testActualCache()
    {
        $output = $this->open('monalisa.jpg')
            ->setCacheDir('/magic/path/to/cache/')
            ->resize(100, 50)->negate()
            ->guess();

        $this->assertContains('/magic/path/to/cache', $output);
        $file = str_replace('/magic/path/to', __DIR__.'/output/', $output);
        $this->assertTrue(file_exists($file));
    }

    public function testCacheData()
    {
        $output = $this->open('monalisa.jpg')
            ->resize(300, 200)
            ->cacheData();

        $jpg = imagecreatefromstring($output);
        $this->assertSame(300, imagesx($jpg));
        $this->assertSame(200, imagesy($jpg));
    }

    /**
     * Testing using cache.
     */
    public function testCache()
    {
        $output = $this->open('monalisa.jpg')
            ->resize(100, 50)->negate()
            ->guess();

        $this->assertTrue(file_exists($output));
        $i = imagecreatefromjpeg($output);
        $this->assertSame(100, imagesx($i));
        $this->assertSame(50, imagesy($i));

        $output2 = $this->open('monalisa.jpg')
            ->resize(100, 50)->negate()
            ->guess();

        $this->assertSame($output, $output2);

        $output3 = $this->open('monalisa.jpg')
            ->resize(100, 50)->negate()
            ->png();
        $this->assertTrue(file_exists($output));
        $i = imagecreatefrompng($output3);
        $this->assertSame(100, imagesx($i));
        $this->assertSame(50, imagesy($i));

        $output4 = $this->open('monalisa.jpg')
            ->resize(100, 50)->negate()
            ->gif();
        $this->assertTrue(file_exists($output));
        $i = imagecreatefromgif($output4);
        $this->assertSame(100, imagesx($i));
        $this->assertSame(50, imagesy($i));
    }

    /**
     * Testing Gaussian blur filter.
     */
    public function testGaussianBlur()
    {
        $image = $this->open('monalisa.jpg')
            ->gaussianBlur();
        $secondImage = $this->open('monalisa.jpg')
            ->gaussianBlur(5);

        $this->assertTrue(file_exists($image));
        $this->assertTrue(file_exists($secondImage));
    }

    /**
     * Testing creating image from data.
     */
    public function testData()
    {
        $data = file_get_contents(__DIR__.'/files/monalisa.jpg');

        $output = $this->output('mona.jpg');
        $image = Image::fromData($data);
        $image->save($output);

        $this->assertTrue(file_exists($output));
        $i = imagecreatefromjpeg($output);
        $this->assertSame(771, imagesx($i));
        $this->assertSame(961, imagesy($i));
    }

    /**
     * Opening an image.
     */
    protected function open($file)
    {
        $image = Image::open(__DIR__.'/files/'.$file);
        $image->setCacheDir(__DIR__.'/output/cache/');
        $image->setActualCacheDir(__DIR__.'/output/cache/');

        return $image;
    }

    /**
     * Testing transparent image.
     */
    public function testTransparent()
    {
        $gif = $this->output('transparent.gif');
        $i = Image::create(200, 100)
            ->fill('transparent')
            ->save($gif, 'gif');

        $this->assertTrue(file_exists($gif));
        $img = imagecreatefromgif($gif);
        $this->assertSame(200, imagesx($img));
        $this->assertSame(100, imagesy($img));
        $index = imagecolorat($img, 2, 2);
        $color = imagecolorsforindex($img, $index);
        $this->assertSame(127, $color['alpha']);
    }

    public function testNonExistingFile()
    {
        $jpg = $this->output('a.jpg');
        $img = $this->open('non_existing_file.jpg')
            ->negate();
        $error = $img->save($jpg);

        $this->assertTrue(file_exists($error));
    }

    /**
     * * @expectedException              \UnexpectedValueException
     */
    public function testNonExistingFileNoFallback()
    {
        Image::open('non_existing_file.jpg')
            ->useFallback(false)
            ->save($this->output('a.jpg'));
    }

    /**
     * Test that image::save returns the file name.
     */
    public function testSaveReturn()
    {
        $red = $this->output('red.jpg');
        $result = Image::create(10, 10)
            ->fill('red')
            ->save($red);

        $this->assertSame($red, $result);
    }

    /**
     * Testing merge.
     */
    public function testMerge()
    {
        $out = $this->output('merge.jpg');
        Image::create(100, 100)
            ->fill('red')
            ->merge(Image::create(50, 50)
                ->fill('black')
            )
            ->save($out);

        // Merge file exists
        $this->assertTrue(file_exists($out));

        // Test that the upper left zone contain a black pixel, and the lower
        // down contains a red one
        $img = imagecreatefromjpeg($out);
        $this->assertColorEquals('black', imagecolorat($img, 5, 12));
        $this->assertColorEquals('red', imagecolorat($img, 55, 62));
    }

    /**
     * Test that dependencies are well generated.
     */
    public function testDependencies()
    {
        $this->assertSame(array(), Image::create(100, 100)
            ->getDependencies());
        $this->assertSame(array(), Image::create(100, 100)
            ->merge(Image::create(100, 50))
            ->getDependencies());

        $this->assertSame(array('toto.jpg'), Image::open('toto.jpg')
            ->merge(Image::create(100, 50))
            ->getDependencies());

        $this->assertSame(array('toto.jpg', 'titi.jpg'), Image::open('toto.jpg')
            ->merge(Image::open('titi.jpg'))
            ->getDependencies());

        $this->assertSame(array('toto.jpg', 'titi.jpg', 'tata.jpg'), Image::open('toto.jpg')
            ->merge(Image::open('titi.jpg')
                    ->merge(Image::open('tata.jpg')))
            ->getDependencies());
    }

    /**
     * Test that pretty name (for referencing) is well respected.
     */
    public function testPrettyName()
    {
        $output = $this->open('monalisa.jpg')
            ->resize(100, 50)->negate()
            ->setPrettyName('davinci', false)
            ->guess();

        $this->assertContains('davinci', $output);

        $output2 = $this->open('monalisa.jpg')
            ->resize(100, 55)->negate()
            ->setPrettyName('davinci', false)
            ->guess();

        $this->assertSame($output, $output2);

        $prefix1 = $this->open('monalisa.jpg')
            ->resize(100, 50)->negate()
            ->setPrettyName('davinci')
            ->guess();
        $prefix2 = $this->open('monalisa.jpg')
            ->resize(100, 55)->negate()
            ->setPrettyName('davinci')
            ->guess();

        $this->assertContains('davinci', $prefix1);
        $this->assertContains('davinci', $prefix2);
        $this->assertNotSame($prefix1, $prefix2);

        $transliterator = '\Behat\Transliterator\Transliterator';

        if (class_exists($transliterator)) {
            $nonLatinName1 = 'ダヴィンチ';
            $nonLatinOutput1 = $this->open('monalisa.jpg')
                ->resize(100, 50)->negate()
                ->setPrettyName($nonLatinName1, false)
                ->guess();

            $this->assertContains(
                $transliterator::urlize($transliterator::transliterate($nonLatinName1)),
                $nonLatinOutput1
            );

            $nonLatinName2 = 'давинчи';
            $nonLatinOutput2 = $this->open('monalisa.jpg')
                ->resize(100, 55)->negate()
                ->setPrettyName($nonLatinName2)
                ->guess();

            $this->assertContains(
                $transliterator::urlize($transliterator::transliterate($nonLatinName2)),
                $nonLatinOutput2
            );
        }
    }

    /**
     * Testing inlining.
     */
    public function testInline()
    {
        $output = $this->open('monalisa.jpg')
            ->resize(20, 20)
            ->inline();

        $this->assertSame(0, strpos($output, 'data:image/jpeg;base64,'));

        $data = base64_decode(substr($output, 23));
        $image = imagecreatefromstring($data);

        $this->assertSame(20, imagesx($image));
        $this->assertSame(20, imagesy($image));
    }

    /**
     * Testing that width() can be called after cache
     */
    public function testWidthPostCache()
    {
        $this->open('monalisa.jpg')
            ->resize(100, 50)->negate()
            ->png();
        
        $dummy2 = $this->open('monalisa.jpg')
            ->resize(100, 50)->negate();
        $png = $dummy2->png();

        $i = imagecreatefrompng($png);
        $this->assertEquals(imagesx($i), $dummy2->width());
    }

    /**
     * Asaserting that two colors are equals
     * (JPG compression is not preserving colors for instance, so we
     * need a non-strict way to compare it).
     */
    protected function assertColorEquals($c1, $c2, $delta = 8)
    {
        $c1 = ImageColor::parse($c1);
        $c2 = ImageColor::parse($c2);
        list($r1, $g1, $b1) = $this->toRGB($c1);
        list($r2, $g2, $b2) = $this->toRGB($c2);

        $this->assertLessThan($delta, abs($r1 - $r2));
        $this->assertLessThan($delta, abs($g1 - $g2));
        $this->assertLessThan($delta, abs($b1 - $b2));
    }

    protected function toRGB($color)
    {
        $b = $color & 0xff;
        $g = ($color >> 8) & 0xff;
        $r = ($color >> 16) & 0xff;

        return array($r, $g, $b);
    }

    /**
     * Outputing an image to a file.
     */
    protected function output($file)
    {
        return __DIR__.'/output/'.$file;
    }

    /**
     * Reinitialize the output dir.
     */
    public function setUp()
    {
        $dir = $this->output('');
        `rm -rf $dir`;
        mkdir($dir);
        mkdir($this->output('cache'));
    }
}
