<?php namespace App\Systems\Guides;

use App\Models\Guides\GuideInfo as Guide;
use App\Models\Core\CoreGames as Games;
use App\Models\Core\CoreLanguages as Languages;

use App\Models\Wiki\WikiEntity;
use App\Models\Wiki\WikiUpdate;

use App\Systems\Core\ImagesManager; //для загрузки картинок

class GuidesManager
{
  private $guide;

  public function __construct(Guide $guide)
  {
    $this->guide = $guide;
  }

  //получение списка игр (для которых можно создать игровой профиль)
  public function listAvailGames()
  {
    $games = Games::wherePlayerAvailable(1)->get();
    return $games;
  }

  //получение списка языков
  public function listLanguages(){
    return Languages::All();
  }

  //Получение информации об игре по слагу
  public function gameInfo($game_slug)
  {
    return Games::whereSlug($game_slug)->firstOrFail();
  }

  //получение класса обработчика игры
  public function getGameClass($game)
  {
    if(!$game) return false;

    if((!$game->module)) return false;

    $guide_class = config($game->module.'.classes.guide');
    if(!$guide_class) return false;

    $class = new $guide_class();
    if(!$class) return false;

    return $class;
  }

  //Генерация фильтра списка гайдов
  public function generateFilter($request)
  {
    $filter = new \stdClass();
    $filter->languages = $this->listLanguages();
    $filter->games = $this->listAvailGames();

    //генерация специального фильтра внутри игры, если выбрана игра
    $game = request()->get('game');

    if(!request()->has('game'))
    {
      $game = global_game();
    }

    if($game)
    {
      $game = Games::find($game);
      if(!$game) return $filter;

      $game_class = $this->getGameClass($game);
      if(!$game_class) return $filter;

      $filter->game_filter = $game_class->generateFilter($game);
    }

    return $filter;
  }

  //Применение фильтра на список гайдов
  public function applyFilter($guides, $request, $user_id = false)
  {
    $game = $request->get('game');
    if($game){
      $game = $request->get('game');
    } else {
      if (!$game && $game != -1) {
        $game = global_game();
      }
    }

    if(!$user_id)
    {
      $game = Games::whereId($game)->first();

      $game->game_class = $this->getGameClass($game);

      if($game->game_class && method_exists($game->game_class,'applyFilter')) {
        $guides->whereGameId($game->id);
        $game->game_class->applyFilter($game, $guides, $request);//применяем фильтр
      }


      $user = auth()->user();
      if($user && $user->info->isAdmin())
      {
        //
      }
      else
        $guides->whereAvailable();
    }

    //Сортировки
    //TODO
    $guides->orderBy('updated_at','desc');
  }

  //Получение представления гайда (в виде элемента списка или отдельной страницы)
  public function guideView($guide, $extended = false)
  {
    //создаем класс профиля
    $game_class = $this->getGameClass($guide->game);
    if(!$game_class) return false;

    //получаем представление с данными (если есть деталеьное представление - получаем его)
    if($extended && method_exists($game_class,'renderExtView'))
    {
      $result = $game_class->renderExtView($guide);
      $guide->extended = true;
    }
    else {
      $result = $game_class->renderView($guide);
    }

    return $result;
  }

  //Получение списка гайдов
  public function listGuides($request, $owner_type = 'all', $owner_id = false, $no_paginate = false)
  {
    $guides = $this->guide->where('guides_info.id', '>', 0)->where('guides_info.owner_id', '>', 0);
    $this->applyFilter($guides,$request,$owner_id);


    if($owner_type != 'all' && in_array($owner_type,['user','clan']))
    {
      $guides->whereOwnerType($owner_type);
      if($owner_id > 0)
      {
        $guides->whereOwnerId($owner_id);
      }
    }

    if($no_paginate)
      $guides = $guides->with(['game','language'])->get();
    else
      $guides = $guides->with(['game','language'])->paginate(config('cm.page_count'));

    if($guides)
      foreach($guides as $guide)
      {
        $guide->view = $this->guideView($guide);
      }

    return $guides;
  }

  //Получение инфы о гайде (с развернутым представлением)
  public function guideInfo($id)
  {
    $guide = $this->guide->with(['game','language'])->findOrFail($id);
    $guide->view = $this->guideView($guide,true);

    return $guide;
  }

  //То же, что и выше, только по слагу
  public function guideInfoSlug($slug)
  {
    $guide = $this->guide->with(['game','language'])->whereSlug($slug)->firstOrFail();
    $guide->view = $this->guideView($guide,true);

    return $guide;
  }

  //Получение формы создания \ редактирования гайда
  public function editForm($game_slug, $slug = false)
  {
    $game = Games::whereSlug($game_slug)->firstOrFail();

    if(!$slug)
      $guide = new Guide();
    else
      $guide = $this->guide->whereGameId($game->id)->whereSlug($slug)->firstOrFail();

    if(!$guide->canEdit()) return false;

    $game_class = $this->getGameClass($game);
    if(!$game_class) return false;

    if($guide->id || ((old('target_type')) && (old('target_id'))))
    {
      if($guide->id)
      {
        $target_type = $guide->target_type;
        $target_id = $guide->target_id;
      }
      else{
        $target_type = old('target_type');
        $target_id = old('target_id');
      }

      $type = $this->checkTargetType($game,$target_type);
      if(!$type)
        return false;

      if($type['target_available'])
        $target = WikiEntity::whereGameId($game->id)->whereCatSlug($target_type)->findOrFail($target_id);
      else
        $target = false;

      $guide->form = $game_class->renderForm($guide, $type, $target);
    }
    else
      $guide->form = false;

    if(!$guide->game_id)
    {
      $guide->game = $game;
    }

    return $guide;
  }

  //Проверка, есть ли такой тип гайда для данной игры
  public function checkTargetType($game, $target_type)
  {
    $type = config($game->module.'.guide_types.'.$target_type);
    if(!$type) return false;

    return $type;
  }

  //Получение списка целей гайда для данного target_type
  public function targetsList($game, $request)
  {
    $target_type = $request->target_type;
    if(!$target_type) return false;

    $game = $this->gameInfo($game);
    if(!$game) return false;

    if(!$this->checkTargetType($game,$target_type))
    {
      return false;
    }

    $targets = WikiEntity::whereGameId($game->id)->whereCatSlug($target_type)->orderBy('name')->get();
    return view('guides.forms.partials.targets_list',['targets' => $targets]);
  }

  //Получение расширенной формы редактирования гайда
  public function extForm($game_slug, $request)
  {
    $target_type = $request->target_type;
    if(!$target_type) return false;

    $game = $this->gameInfo($game_slug);
    if(!$game) return false;

    $type = $this->checkTargetType($game,$target_type);
    if(!$type)
    {
      return false;
    }

    $target_avail = $type['target_available'];

    //Если у гайда должен быть объект - ищем его
    if($target_avail) {
      $target_id = $request->target_id;
      if (!$target_id)
        return false;

      $target = WikiEntity::whereGameId($game->id)->whereCatSlug($target_type)->findOrFail($target_id);
    }
    else{
      //А если нет - не ищем (если это какая-нибудь тактика)
      $target = false;
    }

    $guide = new Guide;

    $game_class = $this->getGameClass($game);
    if(!$game_class) return false;

    return $game_class->renderForm($guide, $type, $target);
  }

  //Создание \ редактирование гайда
  public function guideEdit($game_slug, $slug, $request)
  {
    $game = Games::whereSlug($game_slug)->firstOrFail();

    if(!$slug)
      $guide = new Guide();
    else
      $guide = $this->guide->whereGameId($game->id)->whereSlug($slug)->firstOrFail();

    if(!$guide->canEdit()) return false;

    $game_class = $this->getGameClass($game);
    if(!$game_class) return false;

    //Проверка наличия типа гайда
    $type = $this->checkTargetType($game,$request->target_type);
    if(!$type)
    {
      flash()->error('Неизвестный тип гайда');
      return false;
    }

    if($type['target_available'])
    {
      $target = WikiEntity::whereGameId($game->id)->whereCatSlug($request->target_type)->findOrFail($request->target_id);
      if(!$target)
      {
        flash()->error('Объект гайда не найден');
        return false;
      }
    }
    else{
      $target = false;
      $request->target_id = 0;
    }


    $update_id = $request->update_id;
    if($update_id && $update_id > 0)
    {
      $check_update = WikiUpdate::whereGameId($game->id)->find($update_id);
      if(!$check_update)
      {
        flash()->error('Выбранная версия обновления не найдена');
        return false;
      }
    }
    else
      $update_id = 0;

    //Заполнение базовых параметров
    $guide->name = $request->name;
    $guide->update_id = $update_id;
    $guide->game_id = $game->id;
    $guide->target_type = $request->target_type;
    $guide->target_id = $request->target_id;
    $guide->language_id = $request->language;
    $guide->note = $request->desc;

    if(!$guide->owner_type || !$guide->owner_id)
    {
      $guide->owner_type = 'user'; //Пока что гайды могут добавлять только юзеры
      $guide->owner_id = auth()->id();
    }

    if(!$guide->id)
    {
      //Гайд пока не прошел модерацию
      $guide->active = 1;
      $guide->moderated = 0;
      flash()->message('Гайд отправлен на модерацию и появится в списке, как только модератор проверит его');
    }


    //Если есть - грузим подложку
    if($request->file('image'))
    {
      $guide_image = '/'.$request->image->store('images');

      $image = new ImagesManager;
      $guide_image = $image->toWebp($guide_image);

      if($guide->image && $guide->image != '')
      {
        $image->removeUpload($guide->image);
      }
    }
    else{
      $guide_image = $guide->image;
    }

    $guide->image = $guide_image;

    $game_res = $game_class->editGuide($guide,$request);
    if(!$game_res)
    {
      flash()->error('Ошибка в заполнении параметров игры');
      return false;
    }

    $guide->slug = $request->slug;
    $guide->save();
    //Применяем слаг
    if(strpos($guide->slug,$guide->id.'-') == 0)
      $guide->slug = str_replace($guide->id.'-','',$guide->slug);

    $guide->slug = $guide->id.'-'.$guide->slug;
    $guide->save();

    return $guide;
  }

  //Проголосовать за гайд
  public function guideVote($game_slug, $slug, $request)
  {
    $game = Games::whereSlug($game_slug)->firstOrFail();
    $guide = $this->guide->whereGameId($game->id)->whereSlug($slug)->firstOrFail();

    if(!$guide->canVote())
      return false;

    $vote = $request->vote;
    if(!$vote) return false;
    return $guide->makeVote($vote);
  }

  //Изменить видимость гайда в поиске
  public function guideChangeActive($game_slug, $slug)
  {
    $game = Games::whereSlug($game_slug)->firstOrFail();
    $guide = $this->guide->whereGameId($game->id)->whereSlug($slug)->firstOrFail();

    if(!$guide->canEdit())
      return false;

    $guide->active = !$guide->active;
    $guide->save();

    return true;
  }

  public function guideChangeModerated($game_slug, $slug)
  {
    $game = Games::whereSlug($game_slug)->firstOrFail();
    $guide = $this->guide->whereGameId($game->id)->whereSlug($slug)->firstOrFail();

    if(!$guide->canModerate())
      return false;

    $guide->moderated = !$guide->moderated;
    $guide->moderator_id = auth()->id();
    $guide->save();

    if($guide->moderated)
    {
      //Создаем оповещение чуваку, что его гайд оценили
      \Notifes::createNotif([
          'user_id' => $guide->owner_id,
          'template_slug' => 'guide_moderated',
          'target_type' => 'guide',
          'target_id' => $guide->id,
          'trigger_type' => 'user',
          'trigger_id' => auth()->id(),
          'new' => 1
      ]);

      if($guide->owner_type == 'user')
        $guide->owner->addTransaction('bonuses', 'guide', $guide->id, $guide->name);
    }
    else{
      //Создаем оповещение чуваку, что его гайд оценили
      \Notifes::createNotif([
          'user_id' => $guide->owner_id,
          'template_slug' => 'guide_unmoderated',
          'target_type' => 'guide',
          'target_id' => $guide->id,
          'trigger_type' => 'user',
          'trigger_id' => auth()->id(),
          'new' => 1
      ]);

      if($guide->owner_type == 'user')
        $guide->owner->deleteTransaction('guide', $guide->id);
    }

    return true;
  }

  //Удаление гайда
  public function guideDelete($game_slug, $slug)
  {
    $game = Games::whereSlug($game_slug)->firstOrFail();
    $guide = $this->guide->whereGameId($game->id)->whereSlug($slug)->firstOrFail();

    if(!$guide->canModerate())
      return false;

    $guide->moderated = !$guide->moderated;
    $guide->moderator_id = auth()->id();


    \Notifes::createNotif([
        'user_id' => $guide->owner_id,
        'template_slug' => 'guide_deleted',
        'target_type' => 'guide',
        'target_id' => $guide->id,
        'trigger_type' => 'user',
        'trigger_id' => auth()->id(),
        'new' => 1
    ]);

    $guide->delete();

    if($guide->owner_type == 'user')
      $guide->owner->deleteTransaction('guide', $guide->id);

    return true;
  }

  public function guideRestore($game_slug, $slug)
  {
    $game = Games::whereSlug($game_slug)->firstOrFail();
    $guide = $this->guide->whereGameId($game->id)->whereSlug($slug)->withTrashed()->firstOrFail();

    if(!$guide->canModerate())
      return false;

    $guide->moderated = !$guide->moderated;
    $guide->moderator_id = auth()->id();

    \Notifes::createNotif([
        'user_id' => $guide->owner_id,
        'template_slug' => 'guide_restored',
        'target_type' => 'guide',
        'target_id' => $guide->id,
        'trigger_type' => 'user',
        'trigger_id' => auth()->id(),
        'new' => 1
    ]);

    $guide->restore();

    if($guide->owner_type == 'user' && $guide->moderated)
      $guide->owner->restoreTransaction('guide', $guide->id);

    return true;
  }
}