<?php

namespace App\Komma\Shop\Tests\Unit;

use App\Komma\Shop\Orders\Models\Order;
use App\Komma\Shop\Orders\Product\OrderedProduct;
use App\Komma\Shop\Orders\ProductComposite\OrderedProductComposite;
use App\Komma\Shop\Orders\ProductGroup\OrderedProductGroup;
use App\Komma\Shop\Products\Product\Product;
use App\Komma\Shop\Products\Product\ProductService;
use App\Komma\Shop\Products\ProductComposite\ProductComposite;
use App\Komma\Shop\Products\ProductComposite\ProductCompositeService;
use App\Komma\Shop\Products\ProductGroup\ProductGroup;
use App\Komma\Shop\Products\ProductGroup\ProductGroupService;
use App\Komma\Shop\Products\ProductGroupBehaviour\ProductGroupBehaviour;
use App\Komma\Shop\Tests\TestCase;
use App\Komma\Users\Models\KmsUser;
use Illuminate\Foundation\Testing\DatabaseTransactions;
use Illuminate\Support\Collection;

class OrderTest extends TestCase
{
    use DatabaseTransactions; //Automatically rolls back database actions after tests

    /**
     * @group orderedProducts
     */
    public function testOrderedProductCreation()
    {
        $productService = new ProductService();

        $product = factory(Product::class)->create();
        $this->assertInstanceOf(Product::class, $product);
        /** @var Product $product */

        $this->assertDatabaseHas('products', [
            'price' => $product->price,
            'stock_keeping_unit' => $product->stock_keeping_unit,
        ]);

        $order = factory(Order::class)->create();

        /** @var OrderedProduct $orderedProduct */
        $orderedProduct = $productService->createOrderedProductFromProduct($product, $order);
        $this->assertInstanceOf(OrderedProduct::class, $orderedProduct);


        $this->assertEquals($product->price, $orderedProduct->price);
        $this->assertEquals($product->stock_keeping_unit, $orderedProduct->stock_keeping_unit);
    }

    /**
     * @group orderedProducts
     */
    public function testOrderedGroupCreation()
    {
        $productService = new ProductGroupService();

        $group = factory(ProductGroup::class)->make();
        $behaviour = factory(ProductGroupBehaviour::class)->create();

        $this->assertInstanceOf(ProductGroup::class, $group);
        $this->assertInstanceOf(ProductGroupBehaviour::class, $behaviour);
        /** @var ProductGroup $group */
        /** @var ProductGroupBehaviour $behaviour */

        $group->productGroupBehaviour()->associate($behaviour);
        $group->save();

        $this->assertDatabaseHas('product_groups', [
            'id' => $group->id,
            'active' => $group->active,
        ]);

        $order = factory(Order::class)->create();

        /** @var OrderedProductGroup $orderedProductGroup */
        $orderedProductGroup = $productService->createOrderedProductGroupFromProductGroup($group, $order);

        $this->assertInstanceOf(OrderedProductGroup::class, $orderedProductGroup);



        $this->assertEquals($group->active, $orderedProductGroup->active);
    }

    /**
     * @group orderedProducts
     */
    public function testOrderedCompositeCreation()
    {
        $productCompositeService = new ProductCompositeService();

        $productComposite  = factory(ProductComposite::class)->make();
        $productGroup  = factory(ProductGroup::class)->make();
        $behaviour = factory(ProductGroupBehaviour::class)->create();

        $this->assertInstanceOf(ProductGroup::class, $productGroup);
        $this->assertInstanceOf(ProductGroupBehaviour::class, $behaviour);
        $this->assertInstanceOf(ProductComposite::class, $productComposite);
        /** @var ProductGroup $productGroup */
        /** @var ProductGroupBehaviour $behaviour */
        /** @var ProductComposite $productComposite */

        $productGroup->productGroupBehaviour()->associate($behaviour);
        $productGroup->save();


        $productComposite->save();
        $productComposite->groups()->attach($productGroup);
        $productComposite->save();


        $this->assertDatabaseHas('product_composites', [
            'active' => $productComposite->active,
        ]);

        $order = factory(Order::class)->create();

        /** @var OrderedProduct $orderedComposite */
        $orderedComposite = $productCompositeService->createOrderedProductCompositeProductComposite($productComposite, $order);

        $this->assertInstanceOf(OrderedProductComposite::class, $orderedComposite);

        $this->assertEquals($productComposite->name, $orderedComposite->name);
        $this->assertEquals($productComposite->active, $orderedComposite->active);
    }

    /**
     * @group orderedProducts
     */
    public function testOrderedProductHistory()
    {
        $productService = new ProductService();

        $product = factory(Product::class)->create();

        $order = factory(Order::class)->create();

        /** @var OrderedProduct $orderedProduct */
        $orderedProduct = $productService->createOrderedProductFromProduct($product, $order);
        $this->assertInstanceOf(OrderedProduct::class, $orderedProduct);


        $originalPrice = $product->price;
        $newPrice = $originalPrice + 10000;

        $product->price = $newPrice;
        $product->save();

        $this->assertNotEquals($product->price, $orderedProduct->price);
        $this->assertEquals($product->price, $newPrice);
        $this->assertEquals($orderedProduct->price, $originalPrice);
    }

    /**
     * @group orderedProducts
     */
    public function testOrderedGroupHistory()
    {
        $productGroupService = new ProductGroupService();

        $productsCount = 3;

        /** @var Collection $products */
        $products = factory(Product::class, $productsCount)->create();
        $products = $products->keyBy('id'); //Now we can use ->get(12) on the products collection to get the product with id 12
        $group = factory(ProductGroup::class)->make(); /** @var ProductGroup $group */
        $behaviour = factory(ProductGroupBehaviour::class)->create();

        $group->productGroupBehaviour()->associate($behaviour);
        $group->save();
        $group->products()->saveMany($products);

        $order = factory(Order::class)->create();

        /** @var OrderedProductGroup $orderedProductGroup */
        $orderedProductGroup = $productGroupService->createOrderedProductGroupFromProductGroup($group, $order);

//        echo PHP_EOL.'Testing ordered product group history:';
//        echo PHP_EOL.'Original product prices:';
//        $products->each(function(Product $product) {
//            echo PHP_EOL.$product->id.' => '.$product->price;
//        });
//
//        echo PHP_EOL.'Ordered product prices';
//        $orderedProductGroup->orderedProducts()->get()->each(function(OrderedProduct $orderedProduct) {
//            echo PHP_EOL.$orderedProduct->id.' => '.$orderedProduct->price.' (Original product price: '.$orderedProduct->product()->first()->price.')';
//        });

        //Edit the products prices. The ordered products still have the same price after the loop
        $add = 1000;
        $products->each(function(Product $product) use ($add) {
            $product->price += $add;
            $product->save();
        });

//        echo PHP_EOL.'Modified product prices';
//        $products->each(function(Product $product) {
//            echo PHP_EOL.$product->id.' => '.$product->price;
//        });

        $orderedProductGroupOriginalProducts = $orderedProductGroup->products()->get();
        $this->assertEquals($productsCount, $orderedProductGroupOriginalProducts->count());

        $orderedProductGroupOriginalProducts->each(function(Product $product) use ($products) {
            $originalProduct = $products->get($product->id);
            $this->assertNotNull($originalProduct); //Checks that ordered products original products id's are in the products collection we started with
        });

        $orderedProductGroup->orderedProducts()->get()->each(function(OrderedProduct $orderedProduct) use ($products, $add) {
           $originalProduct = $orderedProduct->product()->first();
           $this->assertNotNull($originalProduct);

           $this->assertNotEquals($orderedProduct->price, $originalProduct->price);
           $this->assertEquals($orderedProduct->price, $originalProduct->price - $add);
        });
    }


    /**
     * @group orderedProducts
     */
    public function testOrderedCompositeHistory()
    {
        $productCompositeService = new ProductCompositeService();

        $productsCount = 3;

        /** @var Collection $products */
        $products = factory(Product::class, $productsCount)->create();
        $products = $products->keyBy('id'); //Now we can use ->get(12) on the products collection to get the product with id 12
        $group = factory(ProductGroup::class)->make(); /** @var ProductGroup $group */
        $behaviour = factory(ProductGroupBehaviour::class)->create();

        $group->productGroupBehaviour()->associate($behaviour);
        $group->save();
        $group->products()->saveMany($products);

        /** @var ProductComposite $composite */
        $composite = factory(ProductComposite::class)->create();
        $composite->groups()->save($group);


        $order = factory(Order::class)->create();

        /** @var OrderedProductComposite $orderedComposite */
        $orderedComposite = $productCompositeService->createOrderedProductCompositeProductComposite($composite, $order);

        //Edit the products prices. The ordered products still have the same price after the loop
        $add = 1000;
        $products->each(function(Product $product) use ($add) {
            $product->price += $add;
            $product->save();
        });

        //Check that the products count is the same as the orignal product count in the orderedProductComposite
        /** @var ProductGroup|null $orderedProductCompositeOriginalGroup */
        $orderedProductCompositeOriginalGroup = $orderedComposite->groups()->first();
        $orderedProductCompositeOriginalProducts = $orderedProductCompositeOriginalGroup->products()->get();
        $this->assertEquals($productsCount, $orderedProductCompositeOriginalProducts->count());

        foreach($orderedProductCompositeOriginalProducts as $product) {
            $originalProduct = $products->get($product->id);
            $this->assertNotNull($originalProduct); //Checks that ordered products original products id's are in the products collection we started with
        };

        /** @var OrderedProductGroup|null $orderedGroup */
        $orderedGroup = $orderedComposite->orderedGroups()->first();
        $this->assertNotNull($orderedGroup);
        $this->assertCount(1, $orderedComposite->orderedGroups()->get());

        $orderedProducts = $orderedGroup->orderedProducts()->get();
        foreach($orderedProducts as $orderedProduct) {
            $originalProduct = $orderedProduct->product()->first();
            $this->assertNotNull($originalProduct);

            $this->assertNotEquals($orderedProduct->price, $originalProduct->price);
            //The original product was 1000 cents more than the ordered one. So you can also say that the orderedProduct->price + 1000 cents is the same as the original product price
            $this->assertEquals($orderedProduct->price + $add, $originalProduct->price);
        };
    }
}