<?php

/**
 * @author      Pascal Lemmen <pascal@komma.pro>
 * @copyright   (c) 2012-2016, Komma Mediadesign
 */

namespace Komma\Kms\Jobs;

use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Route;
use Komma\Kms\Core\Entities\KmsHierarchicalListItemEntity;
use Komma\Kms\Core\Kms;
use Komma\Kms\Core\KmsRepository;
use Komma\Kms\Core\Routes\KmsRoute;
use Komma\Kms\Core\Routes\RoutableInterface;
use Komma\Kms\Core\Tree\Tree;
use Komma\Kms\Files\FileRepository;
use Komma\Kms\Pages\Models\Page;
use Komma\Kms\Jobs\Models\Job;
use Komma\Kms\Jobs\Models\JobTranslation;
use Komma\Kms\Images\ImageService;
use Komma\Kms\Schools\School;
use Komma\Kms\Schools\SchoolService;

class JobRepository extends KmsRepository
{

    private $imageService;
    private $fileRespository;
    protected $modelType = 'Komma\\Kms\\Jobs\\Models\\Job';

    /**
     * @var Tree
     */
    protected $tree;


    /**
     * Call the parent __construct
     * inject the dependencies.
     *
     * BlockRepository constructor.
     * @param Kms $kms
     * @param ImageService $imageService
     */
    function __construct(Kms $kms, ImageService $imageService, FileRepository $fileRepository, Tree $tree)
    {
        parent::__construct($kms);
        $this->imageService = $imageService;
        $this->fileRespository = $fileRepository;
        $this->fileRespository->setRelatedModel('Komma\\Kms\\Jobs\\Models\\Job');
        $this->tree = $tree;
    }


    public function newEntity()
    {
        $block = new Job();
        $entity = new JobEntity($block->toArray());
        foreach ($this->kms->getCurrentLanguages() as $language)
        {
            $entity->addTranslationEntity(new JobTranslationEntity($language->id));
        }

        return $entity;
    }

    public function getEntity($id)
    {
        if($id == null) return $this->newEntity();

        $model = Job::find($id);
        // Transform for page_id
        if( ! $model) return false;

        $entity = new JobEntity($model->toArray());
        $entity->parent_id = $model->getParentId();

        $entity->file = $this->fileRespository->filesFromModel($id);

        foreach ($model->translations as $translation)
        {
            $entity->addTranslationEntity(
                new JobTranslationEntity(
                    $translation->language_id,
                    $translation->attributesToArray()
                )
            );
        }

        return $entity;

    }

    public function getEntities()
    {
        $tree = $this->getEntitiesAsTree();
        $this->makeRootIfNotExists();
        return $tree;
    }

    public function getEntitiesAsTree(){

        $records = Job::orderBy('lft')->get();

        $entities = [];
        foreach ($records as $record)
        {
            $blockEntity = new JobEntity($record->toArray());
            if($images = $this->getImages($record['id'], $this->modelType, 'person'))
            {
                $blockEntity->thumbnail = $images['0']['thumb_image_url'];
            }
            $entities[] = $blockEntity;
        }

        $categories = [];
        foreach ($entities as $record)
        {
            $record = (array)$record;
            //Get the first image for the thumb
            if($images = $this->getImages($record['id'], 'Komma\\Kms\\References\\Models\\Job'))
            {
                $record['thumbnail'] = $images['0']['thumb_image_url'];
            }

            $categories[] = new KmsHierarchicalListItemEntity($record);
        }

        $tree = new Tree();
        $tree->make($categories);

        return $tree;

    }


    /**
     * @param JobEntity $entity
     * @return JobEntity
     */
    public function saveEntity(JobEntity $entity)
    {
        $record = Job::firstOrNew(['id' => $entity->id]);

        if($record->id == null)
        {
            $record->makeFirstChildOf(Job::where('lft', '=', 1)->first());
        }

        $record->name = \Input::get('name');
        $record->active = \Input::get('active');
        $record->page_code_name = \Input::get('page_code_name');
        $record->pay = \Input::get('pay');
        $record->contract = \Input::get('contract');
        $record->possibilities = \Input::get('possibilities');
        $record->contact_phone = \Input::get('contact_phone');
        $record->contact_whatsapp = \Input::get('contact_whatsapp');
        $record->contact_email = \Input::get('contact_email');

        $record->contact_phone_name = \Input::get('contact_phone_name');
        $record->contact_whatsapp_name = \Input::get('contact_whatsapp_name');
        $record->contact_email_name = \Input::get('contact_email_name');


        $record->save();

        // Append id to entity for restfull routing
        $entity->id = $record->id;

        if($entity->schools != 0)
        {
            $record->schools()->sync($entity->schools);
        }
        else
        {
            $record->schools()->detach();
        }

        //save the translations
        foreach ($this->kms->getCurrentLanguages() as $language)
        {

            $translation = JobTranslation::firstOrNew(['job_id' => $record->id, 'language_id' => $language->id]);
            $translation->description = \Input::get('description_' . $language->id);
            $translation->save();


        }

        $this->saveRoutes($record);

        // Delete old and save new file to the repository
        $this->fileRespository->store($entity->file, $record->id);

        // Get remaining files from the repository
        $record->file = $this->fileRespository->filesFromModel($record->id);

        //Link the images to this model
        $this->imageService->linkImagesToModel('person', $record);

        return $entity;
    }

    public function destroyEntity($id)
    {
        if($images = $this->getImages($id, $this->modelType))
        {
            //Delete the images
            $images = $this->imageSerivce->getImages();
            $this->imageSerivce->deleteImages($images);
        }

        //Delete Routes
        KmsRoute::where('rest_route', '=', 'references/' . $id)->delete();

        $entity = Job::find($id);
        $entity->delete();


    }

    protected function saveRoutes(Job $job)
    {

        // Gather the saved routes
        $savedRoutes = [];

        $page = Page::where('code_name', 'jobs')->first();

        // If site should be multi language rewrite this
        $pageRoute = $page->translations->first()->routes->first()->route;
        $referenceRoute = $pageRoute . '/' . \Str::slug($job->name);

        foreach ($job->translations as $translation)
        {
            $routeString = $this->makeRouteUnique($translation, $referenceRoute);

            if($route = $this->getRouteByTranslationIdAndRoute($translation->id, $routeString))
            {
                $route->route = $routeString;
                $route->rest_route = 'jobs/' . $job->id;
                $route->save();
            }
            else
            {
                $route = new KmsRoute([
                    'route'      => $routeString,
                    'rest_route' => 'jobs/' . $job->id
                ]);
                $translation->routes()->save($route);
            }

            $savedRoutes[] = $routeString;

        }


        $this->removeUnusedRoutes($job, $savedRoutes);
    }

    public function makeRouteUnique($routeable, $route)
    {
        $routes = KmsRoute::where('route', '=', $route)
            ->Join('reference_translations', 'routes.routable_id', '=', 'reference_translations.id')
            ->where('reference_translations.language_id', '=', $routeable->language_id)
            ->where(function ($query) use ($routeable) {
                $query->where('routable_id', '!=', $routeable->id);
                $query->where('routable_type', '==', get_class($routeable));
            })
            ->get();
        if($routes->count() == 0) return $route;

        return $this->makeRouteUnique($routeable, $route . '-1');
    }


    public function getRoutesByTranslation($translationId)
    {
        if($route = JobTranslation::find($translationId))
        {
            return $route->routes()->get();
        }

        return null;
    }

    public function getRouteByTranslationIdAndRoute($referenceId, $routeString)
    {
        if($route = JobTranslation::find($referenceId))
        {
            foreach ($route->routes()->get() as $route)
            {
                if($route->route == $routeString) return $route;
            }

            return false;
        }

        return null;
    }

    public function findAllRoutesOfReferences(Job $reference)
    {
        $routes = [];

        foreach ($reference->translations()->get() as $referenceTranslation)
        {
            foreach ($referenceTranslation->routes()->get() as $referenceRoute)
            {
                $routes[] = $referenceRoute;
            }
        }

        return $routes;
    }

    public function removeUnusedRoutes(Job $reference, $usedRoutes)
    {

        // Get all Routes of all translations and schools
        $allReferenceRoutes = $this->findAllRoutesOfReferences($reference);

        foreach ($allReferenceRoutes as $referenceRoute)
        {
            // If in used routes array, continue
            if(in_array($referenceRoute->route, $usedRoutes)) continue;

            // Else remove this route
            $referenceRoute->delete();
        }
    }

    protected function makeRootIfNotExists()
    {
        $model = Job::where('lft', 1)
            ->first();
        if( ! $model)
        {
            $model = new Job();
            $model->makeRoot();
        }
    }

}