/*                                                                  -*- c++ -*-
Copyright (C) 2004-2013 Christian Wieninger

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Or, point your browser to http://www.gnu.org/licenses/old-licenses/gpl-2.0.html

The author can be reached at cwieninger@gmx.de

The project's page is at http://winni.vdr-developer.org/epgsearch
*/

#include <vector>
#include <string>
#include "menu_commands.h"
#include <vdr/interface.h>
#include <vdr/menu.h>
#include <vdr/plugin.h>
#include "menu_searchactions.h"
#include "menu_searchresults.h"
#include "menu_recsdone.h"
#include "menu_timersdone.h"
#include "menu_switchtimers.h"
#include "menu_blacklists.h"
#include "epgsearchtools.h"
#include "menu_conflictcheck.h"
#include "epgsearchcfg.h"
#include "searchtimer_thread.h"
#include "menu_searchedit.h"

using namespace std;

#define ACTION_COUNTER 11
extern int updateForced;
// --- cMenuSearchActions ---------------------------------------------------------

cMenuSearchActions::cMenuSearchActions(cSearchExt* Search, bool DirectCall)
    : cOsdMenu(tr("Search actions"))
{
    SetMenuCategory(mcCommand);
    directCall = DirectCall;
    SetHasHotkeys();

    search = Search;

    Add(new cOsdItem(hk(tr("Execute search"))));
    Add(new cOsdItem(hk(tr("Use as search timer on/off"))));
    Add(new cOsdItem(hk(tr("Trigger search timer update"))));
    Add(new cOsdItem(hk(tr("Show recordings done"))));
    Add(new cOsdItem(hk(tr("Show timers created"))));
    Add(new cOsdItem(hk(tr("Create a copy"))));
    Add(new cOsdItem(hk(tr("Use as template"))));
    Add(new cOsdItem(hk(tr("Show switch list"))));
    Add(new cOsdItem(hk(tr("Show blacklists"))));
    Add(new cOsdItem(hk(tr("Delete created timers?"))));
    Add(new cOsdItem(hk(tr("Timer conflict check"))));
}

cMenuSearchActions::~cMenuSearchActions()
{
}


eOSState cMenuSearchActions::Search(void)
{
    cMenuTemplate* MenuTemplate = NULL;
    if (!search) return osContinue;
    if (search->menuTemplate > 0)
        MenuTemplate = cTemplFile::GetSearchTemplateByPos(search->menuTemplate);
    if (!MenuTemplate)
        MenuTemplate = cTemplFile::GetTemplateByName("MenuSearchResults");
    return AddSubMenu(new cMenuSearchResultsForSearch(search, MenuTemplate));
}

eOSState cMenuSearchActions::OnOffSearchtimer(void)
{
    if (search) {
        search->useAsSearchTimer = search->useAsSearchTimer ? 0 : 1;
        SearchExts.Save();
        if (!search->useAsSearchTimer && Interface->Confirm(tr("Disable associated timers too?")))
            search->OnOffTimers(false);
        if (search->useAsSearchTimer && Interface->Confirm(tr("Activate associated timers too?"))) {
            search->OnOffTimers(true);
            if (!EPGSearchConfig.useSearchTimers) { // enable search timer thread if necessary
                cSearchTimerThread::Init((cPluginEpgsearch*) cPluginManager::GetPlugin("epgsearch"), true);
                INFO(tr("Search timers activated in setup."));
            }
        }
    }
    return osBack;
}


eOSState cMenuSearchActions::Execute()
{
    int current = Current();

    if (current <= ACTION_COUNTER - 1) {
        if (current == 0)
            return Search();
        if (current == 1)
            return OnOffSearchtimer();
        if (current == 2) {
            if (!EPGSearchConfig.useSearchTimers) { // enable search timer thread if necessary
                cSearchTimerThread::Init((cPluginEpgsearch*) cPluginManager::GetPlugin("epgsearch"), true);
                INFO(tr("Search timers activated in setup."));
            }
            if (Interface->Confirm(tr("Run search timer update?")))
                updateForced = 3; // with message about completion
            return osBack;
        }
        if (current == 3 && search)
            return AddSubMenu(new cMenuRecsDone(search));
        if (current == 4 && search)
            return AddSubMenu(new cMenuTimersDone(search));
        if (current == 5 && search) {
            if (!Interface->Confirm(tr("Copy this entry?")))
                return osBack;
            cSearchExt* copy = new cSearchExt;
            copy->CopyFromTemplate(search);
            string copyname = string(tr("Copy")) + ": " + search->search;
            strcpy(copy->search, copyname.c_str());
            cMutexLock SearchExtsLock(&SearchExts);
            copy->ID = SearchExts.GetNewID();
            SearchExts.Add(copy);
            SearchExts.Save();
            return AddSubMenu(new cMenuEditSearchExt(copy));
        }
        if (current == 6 && search) {
            if (!Interface->Confirm(tr("Copy this entry to templates?")))
                return osBack;
            cSearchExt* templateObj = new cSearchExt;
            templateObj->CopyFromTemplate(search);
            strcpy(templateObj->search, search->search);
            cMutexLock SearchTemplatesLock(&SearchTemplates);
            templateObj->ID = SearchTemplates.GetNewID();
            SearchTemplates.Add(templateObj);
            SearchTemplates.Save();
            return osBack;
        }
        if (current == 7)
            return AddSubMenu(new cMenuSwitchTimers());
        if (current == 8)
            return AddSubMenu(new cMenuBlacklists());
        if (current == 9) {
            if (!Interface->Confirm(tr("Delete all timers created from this search?")))
                return osBack;
            search->DeleteAllTimers();
            return osBack;
        }
        if (current == 10)
            return AddSubMenu(new cMenuConflictCheck());
    }
    return osContinue;
}

eOSState cMenuSearchActions::ProcessKey(eKeys Key)
{
    bool hadSubmenu = HasSubMenu();
    if (directCall && Key == k1 && !HasSubMenu())
        return Search();

    eOSState state = cOsdMenu::ProcessKey(Key);

    // jump back to calling menu, if a command was called directly with key '1' .. '9'
    if (directCall && hadSubmenu && !HasSubMenu())
        return osBack;

    if (state == osUnknown) {
        switch (Key) {
        case kGreen:
        case kYellow:
        case kBlue:
            return osContinue;
        case kOk:
            if (!HasSubMenu())
                return Execute();
        default:
            break;
        }
    }
    return state;
}