/*
Copyright (C) 2012 Sebastian Herbord. All rights reserved.

This file is part of Mod Organizer.

Mod Organizer 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 3 of the License, or
(at your option) any later version.

Mod Organizer 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 Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "executableslist.h"

#include "iplugingame.h"
#include "utility.h"

#include <QFileInfo>
#include <QDir>
#include <QDebug>
#include <QCoreApplication>


#include <algorithm>


using namespace MOBase;


ExecutablesList::ExecutablesList()
{
}

ExecutablesList::~ExecutablesList()
{
}

void ExecutablesList::init(IPluginGame const *game)
{
  Q_ASSERT(game != nullptr);
  m_Executables.clear();
  for (const ExecutableInfo &info : game->executables()) {
    if (info.isValid()) {
      addExecutableInternal(info.title(),
                            info.binary().absoluteFilePath(),
                            info.arguments().join(" "),
                            info.workingDirectory().absolutePath(),
                            info.steamAppID());
    }
  }
  ExecutableInfo explorerpp = ExecutableInfo("Explore Virtual Folder", QFileInfo(QCoreApplication::applicationDirPath() + "/explorer++/Explorer++.exe" ))
      .withArgument(QString("\"%1\"").arg(QDir::toNativeSeparators(game->dataDirectory().absolutePath())));

  if (explorerpp.isValid()) {
    addExecutableInternal(explorerpp.title(),
      explorerpp.binary().absoluteFilePath(),
      explorerpp.arguments().join(" "),
      explorerpp.workingDirectory().absolutePath(),
      explorerpp.steamAppID());
  }

}

void ExecutablesList::getExecutables(std::vector<Executable>::iterator &begin, std::vector<Executable>::iterator &end)
{
  begin = m_Executables.begin();
  end = m_Executables.end();
}

void ExecutablesList::getExecutables(std::vector<Executable>::const_iterator &begin,
                                     std::vector<Executable>::const_iterator &end) const
{
  begin = m_Executables.begin();
  end = m_Executables.end();
}

const Executable &ExecutablesList::find(const QString &title) const
{
  for (Executable const &exe : m_Executables) {
    if (exe.m_Title == title) {
      return exe;
    }
  }
  throw std::runtime_error(QString("invalid executable name: %1").arg(title).toLocal8Bit().constData());
}


Executable &ExecutablesList::find(const QString &title)
{
  for (Executable &exe : m_Executables) {
    if (exe.m_Title == title) {
      return exe;
    }
  }
  throw std::runtime_error(QString("invalid executable name: %1").arg(title).toLocal8Bit().constData());
}


Executable &ExecutablesList::findByBinary(const QFileInfo &info)
{
  for (Executable &exe : m_Executables) {
    if (info == exe.m_BinaryInfo) {
      return exe;
    }
  }
  throw std::runtime_error("invalid info");
}


std::vector<Executable>::iterator ExecutablesList::findExe(const QString &title)
{
  for (std::vector<Executable>::iterator iter = m_Executables.begin(); iter != m_Executables.end(); ++iter) {
    if (iter->m_Title == title) {
      return iter;
    }
  }
  return m_Executables.end();
}


bool ExecutablesList::titleExists(const QString &title) const
{
  auto test = [&] (const Executable &exe) { return exe.m_Title == title; };
  return std::find_if(m_Executables.begin(), m_Executables.end(), test) != m_Executables.end();
}


void ExecutablesList::addExecutable(const Executable &executable)
{
  auto existingExe = findExe(executable.m_Title);
  if (existingExe != m_Executables.end()) {
    *existingExe = executable;
  } else {
    m_Executables.push_back(executable);
  }
}


void ExecutablesList::updateExecutable(const QString &title,
                                       const QString &executableName,
                                       const QString &arguments,
                                       const QString &workingDirectory,
                                       const QString &steamAppID,
                                       Executable::Flags mask,
                                       Executable::Flags flags)
{
  QFileInfo file(executableName);
  QDir dir(workingDirectory);
  auto existingExe = findExe(title);
  flags &= mask;

  if (existingExe != m_Executables.end()) {
    existingExe->m_Title = title;
    existingExe->m_Flags &= ~mask;
    existingExe->m_Flags |= flags;
    // for pre-configured executables don't overwrite settings we didn't store
    if (flags & Executable::CustomExecutable) {
      if (file.exists()) {
        // don't overwrite a valid binary with an invalid one
        existingExe->m_BinaryInfo = file;
      }
      if (dir.exists()) {
        // don't overwrite a valid working directory with an invalid one
        existingExe->m_WorkingDirectory = workingDirectory;
      }
      existingExe->m_Arguments = arguments;
      existingExe->m_SteamAppID = steamAppID;
    }
  } else {
    Executable newExe;
    newExe.m_Title = title;
    newExe.m_BinaryInfo = file;
    newExe.m_Arguments = arguments;
    newExe.m_WorkingDirectory = workingDirectory;
    newExe.m_SteamAppID = steamAppID;
    newExe.m_Flags = Executable::CustomExecutable | flags;
    m_Executables.push_back(newExe);
  }
}


void ExecutablesList::remove(const QString &title)
{
  for (std::vector<Executable>::iterator iter = m_Executables.begin(); iter != m_Executables.end(); ++iter) {
    if (iter->isCustom() && (iter->m_Title == title)) {
      m_Executables.erase(iter);
      break;
    }
  }
}


void ExecutablesList::addExecutableInternal(const QString &title, const QString &executableName,
                                            const QString &arguments, const QString &workingDirectory,
                                            const QString &steamAppID)
{
  QFileInfo file(executableName);
  if (file.exists()) {
    Executable newExe;
    newExe.m_BinaryInfo = file;
    newExe.m_Title = title;
    newExe.m_Arguments = arguments;
    newExe.m_WorkingDirectory = workingDirectory;
    newExe.m_SteamAppID = steamAppID;
    newExe.m_Flags = Executable::UseApplicationIcon;
    m_Executables.push_back(newExe);
  }
}


void Executable::showOnToolbar(bool state)
{
  if (state) {
    m_Flags |= ShowInToolbar;
  } else {
    m_Flags &= ~ShowInToolbar;
  }
}