#include "mainwindow.h"
#include "imageselector.h"
#include "imageswitcher.h"
#include "pathtraverser.h"
#include "immichpathtraverser.h"
#include "mqttcontroller.h"
#include "overlay.h"
#include "appconfig.h"
#include "logger.h"

#include <QApplication>
#include <QRegularExpression>
#include <iostream>
#include <sys/file.h>
#include <errno.h>

#include <getopt.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <memory>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonArray>

void usage(std::string programName) {
    std::cerr << "Usage: " << programName << " [-t rotation_seconds] [-T transition_seconds] [-h/--overlay-color #rrggbb] [-a aspect('l','p','a', 'm')] [-o background_opacity(0..255)] [-b blur_radius] -p image_folder [-r] [-s] [-S] [-v] [--verbose] [--stretch] [-c config_file_path]" << std::endl;
}

bool parseCommandLine(AppConfig &appConfig, int argc, char *argv[]) {
  int opt;
  int debugInt = 0;
  int stretchInt = 0;
  static struct option long_options[] =
  {
    {"verbose",       no_argument,       &debugInt,   1},
    {"stretch",       no_argument,       &stretchInt, 1},
    {"overlay-color", required_argument, 0,           'h'},
  };
  int option_index = 0;
  while ((opt = getopt_long(argc, argv, "b:p:t:T:o:O:a:i:c:h:rsSv", long_options, &option_index)) != -1) {
    switch (opt) {
      case 0:
          /* If this option set a flag, do nothing else now. */
          if (long_options[option_index].flag != 0)
            break;
          return false;
          break;
      case 'p':
        if(appConfig.paths.count() == 0)
          appConfig.paths.append(PathEntry());
        appConfig.paths[0].path = optarg;
        break;
      case 'a':
        if (appConfig.valid_aspects.find(optarg[0]) == std::string::npos)
        {
          std::cout << "Invalid Aspect option, defaulting to all" << std::endl;
          appConfig.baseDisplayOptions.onlyAspect = ImageAspectScreenFilter_Any;
        }
        else
        {
          appConfig.baseDisplayOptions.onlyAspect = parseAspectFromString(optarg[0]);
        }
        break;
      case 't':
        appConfig.rotationSeconds = atoi(optarg);
        break;
      case 'T':
	      appConfig.transitionTime =atoi(optarg);
        break;
      case 'b':
        appConfig.blurRadius = atoi(optarg);
        break;
      case 'o':
        appConfig.backgroundOpacity = atoi(optarg);
        break;
      case 'r':
        if(appConfig.paths.count() == 0)
          appConfig.paths.append(PathEntry());
        appConfig.paths[0].recursive = true;
        break;
      case 's':
        if(appConfig.paths.count() == 0)
          appConfig.paths.append(PathEntry());
        appConfig.paths[0].shuffle = true;
        std::cout << "Shuffle mode is on." << std::endl;
        break;
      case 'S':
        if(appConfig.paths.count() == 0)
          appConfig.paths.append(PathEntry());
        appConfig.paths[0].sorted = true;
        break;
      case 'O':
        appConfig.overlay = optarg;
        break;
      case 'h':
        appConfig.overlayHexRGB = QString::fromStdString(optarg);
        break;
      case 'v':
        appConfig.debugMode = true;
        break;
      case 'i':
        if(appConfig.paths.count() == 0)
          appConfig.paths.append(PathEntry());
        appConfig.paths[0].imageList = optarg;
        break;
      case 'c':
        appConfig.configPath = optarg;
        break;
      default: /* '?' */
        return false;
    }
  }
  
  if(debugInt==1)
  {
    appConfig.debugMode = true;
  }
  if(stretchInt==1)
  {
    appConfig.baseDisplayOptions.fitAspectAxisToWindow = true;
  }

  return true;
}

void ConfigureWindowFromSettings(MainWindow &w, const AppConfig &appConfig)
{
  if (appConfig.blurRadius>= 0)
  {
    w.setBlurRadius(appConfig.blurRadius);
  }

  if (appConfig.backgroundOpacity>= 0)
  {
      w.setBackgroundOpacity(appConfig.backgroundOpacity);
  }

  w.setTransitionTime(appConfig.transitionTime);

  if (!appConfig.overlayHexRGB.isEmpty())
  {
    QRegularExpression hexRGBMatcher("^#([0-9A-Fa-f]{3}){1,2}$");
    if(!hexRGBMatcher.match(appConfig.overlayHexRGB).hasMatch())
    {
      std::cout << "Error: hex rgb string expected. e.g. #FFFFFF or #FFF" << std::endl;
    }
    else
    {
      w.setOverlayHexRGB(appConfig.overlayHexRGB);
    }
  }

  if (!appConfig.overlay.empty()) 
  {
    std::unique_ptr<Overlay> o = std::unique_ptr<Overlay>(new Overlay(appConfig.overlay));
    w.setOverlay(o);
  }
  w.setBaseOptions(appConfig.baseDisplayOptions);
}

std::unique_ptr<ImageSelector> GetSelectorForConfig(const PathEntry& path)
{
  std::unique_ptr<PathTraverser> pathTraverser;
  if (path.immich.enabled)
  {
    pathTraverser = std::unique_ptr<PathTraverser>(new ImmichPathTraverser(path.immich));
  }
  else if (!path.imageList.empty())
  {
    pathTraverser = std::unique_ptr<PathTraverser>(new ImageListPathTraverser(path.imageList));
  }
  else if (path.recursive)
  {
    pathTraverser = std::unique_ptr<PathTraverser>(new RecursivePathTraverser(path.path));
  }
  else
  {
    pathTraverser = std::unique_ptr<PathTraverser>(new DefaultPathTraverser(path.path));
  }

  std::unique_ptr<ImageSelector> selector;
  if (path.sorted)
  {
    selector = std::unique_ptr<ImageSelector>(new SortedImageSelector(pathTraverser));
  }
  else if (path.shuffle)
  {
    selector = std::unique_ptr<ImageSelector>(new ShuffleImageSelector(pathTraverser));
  }
  else
  {
    selector = std::unique_ptr<ImageSelector>(new RandomImageSelector(pathTraverser));
  }

  return selector;
}

std::unique_ptr<ImageSelector> GetSelectorForApp(const AppConfig& appConfig)
{
  if(appConfig.paths.count()==1)
  {
    return GetSelectorForConfig(appConfig.paths[0]);
  }
  else
  {
    std::unique_ptr<ListImageSelector> listSelector(new ListImageSelector());
    for(const auto &path : appConfig.paths)
    {
      auto selector = GetSelectorForConfig(path);
      listSelector->AddImageSelector(selector, path.exclusive, path.baseDisplayOptions);
    }
    // new things
    return listSelector;
  }
}


void ReloadConfigIfNeeded(AppConfig &appConfig, MainWindow &w, ImageSwitcher *switcher)
{  
  if(appConfig.configPath.empty())
  {
    return;
  }
  
  QString jsonFile = getAppConfigFilePath(appConfig.configPath);
  QDir directory;
  if(!directory.exists(jsonFile))
  {
    return;
  }

  if(appConfig.loadTime <  QFileInfo(jsonFile).lastModified())
  {
    AppConfig oldConfig = appConfig;
    appConfig = loadAppConfiguration(appConfig);

    ConfigureWindowFromSettings(w, appConfig);
    if(appConfig.PathOptionsChanged(oldConfig))
    {
      std::unique_ptr<ImageSelector> selector = GetSelectorForApp(appConfig);
      switcher->setImageSelector(selector);
    }

    switcher->setRotationTime(appConfig.rotationSeconds * 1000);
  }
}

static bool ParseBooleanString(const QString &value, bool &outValue)
{
  QString v = value.trimmed().toLower();
  if (v == "true" || v == "1" || v == "yes" || v == "on")
  {
    outValue = true;
    return true;
  }
  if (v == "false" || v == "0" || v == "no" || v == "off")
  {
    outValue = false;
    return true;
  }
  return false;
}

static std::vector<std::string> SplitCsv(const QString &value)
{
  std::vector<std::string> output;
  QStringList parts = value.split(',', Qt::SkipEmptyParts);
  for (const auto &part : parts)
  {
    QString trimmed = part.trimmed();
    if (!trimmed.isEmpty())
      output.push_back(trimmed.toStdString());
  }
  return output;
}

static bool ApplyImmichPayload(ImmichConfig &config, const QString &payload)
{
  bool changed = false;
  QString trimmed = payload.trimmed();
  if (trimmed.isEmpty())
    return false;

  if (trimmed.startsWith("{"))
  {
    QJsonDocument doc = QJsonDocument::fromJson(trimmed.toUtf8());
    if (!doc.isObject())
      return false;
    QJsonObject obj = doc.object();

    if (obj.contains("albumId") && obj["albumId"].isString())
    {
      config.albumIds = { obj["albumId"].toString().toStdString() };
      changed = true;
    }
    if (obj.contains("albumIds") && obj["albumIds"].isArray())
    {
      config.albumIds.clear();
      QJsonArray arr = obj["albumIds"].toArray();
      for (const auto &value : arr)
      {
        if (value.isString())
          config.albumIds.push_back(value.toString().toStdString());
      }
      changed = true;
    }
    if (obj.contains("personId") && obj["personId"].isString())
    {
      config.personIds = { obj["personId"].toString().toStdString() };
      changed = true;
    }
    if (obj.contains("personIds") && obj["personIds"].isArray())
    {
      config.personIds.clear();
      QJsonArray arr = obj["personIds"].toArray();
      for (const auto &value : arr)
      {
        if (value.isString())
          config.personIds.push_back(value.toString().toStdString());
      }
      changed = true;
    }
    if (obj.contains("order") && obj["order"].isString())
    {
      config.order = obj["order"].toString().toStdString();
      changed = true;
    }
    if (obj.contains("size") && obj["size"].isString())
    {
      config.size = obj["size"].toString().toStdString();
      changed = true;
    }
    if (obj.contains("pageSize") && obj["pageSize"].isDouble())
    {
      config.pageSize = (int)obj["pageSize"].toDouble();
      changed = true;
    }
    if (obj.contains("maxAssets") && obj["maxAssets"].isDouble())
    {
      config.maxAssets = (int)obj["maxAssets"].toDouble();
      changed = true;
    }
    if (obj.contains("includeArchived"))
    {
      if (obj["includeArchived"].isBool())
      {
        config.includeArchived = obj["includeArchived"].toBool();
        changed = true;
      }
      else if (obj["includeArchived"].isString())
      {
        bool parsed = false;
        bool boolValue = false;
        parsed = ParseBooleanString(obj["includeArchived"].toString(), boolValue);
        if (parsed)
        {
          config.includeArchived = boolValue;
          changed = true;
        }
      }
    }
    if (obj.contains("reset") && obj["reset"].isBool() && obj["reset"].toBool())
    {
      config.albumIds.clear();
      config.personIds.clear();
      changed = true;
    }
    return changed;
  }

  QString key;
  QString value;
  int idx = trimmed.indexOf('=');
  if (idx < 0)
    idx = trimmed.indexOf(':');
  if (idx < 0)
    idx = trimmed.indexOf(' ');

  if (idx >= 0)
  {
    key = trimmed.left(idx).trimmed().toLower();
    value = trimmed.mid(idx + 1).trimmed();
  }
  else
  {
    key = trimmed.toLower();
  }

  if (key == "reset" || key == "clear" || key == "all")
  {
    config.albumIds.clear();
    config.personIds.clear();
    return true;
  }
  if (key == "album" || key == "albumid")
  {
    config.albumIds = { value.toStdString() };
    return true;
  }
  if (key == "albums" || key == "albumids")
  {
    config.albumIds = SplitCsv(value);
    return true;
  }
  if (key == "person" || key == "personid")
  {
    config.personIds = { value.toStdString() };
    return true;
  }
  if (key == "persons" || key == "personids")
  {
    config.personIds = SplitCsv(value);
    return true;
  }
  if (key == "order")
  {
    config.order = value.toStdString();
    return true;
  }
  if (key == "size")
  {
    config.size = value.toStdString();
    return true;
  }
  if (key == "includearchived")
  {
    bool boolValue = false;
    if (ParseBooleanString(value, boolValue))
    {
      config.includeArchived = boolValue;
      return true;
    }
  }
  if (key == "pagesize")
  {
    bool ok = false;
    int parsed = value.toInt(&ok);
    if (ok)
    {
      config.pageSize = parsed;
      return true;
    }
  }
  if (key == "maxassets")
  {
    bool ok = false;
    int parsed = value.toInt(&ok);
    if (ok)
    {
      config.maxAssets = parsed;
      return true;
    }
  }

  return false;
}

int main(int argc, char *argv[])
{
  QApplication a(argc, argv);

  AppConfig commandLineAppConfig;
  if (!parseCommandLine(commandLineAppConfig, argc, argv))
  {
    usage(argv[0]);
    return 1;
  }

  AppConfig appConfig = loadAppConfiguration(commandLineAppConfig);

  if (appConfig.paths.empty())
  {
    std::cout << "Error: Path expected." << std::endl;
    usage(argv[0]);
    return 1;
  }
  SetupLogger(appConfig.debugMode);
  Log( "Rotation Time: ", appConfig.rotationSeconds );
  Log( "Overlay input: ", appConfig.overlay );
  
  MainWindow w;
  ConfigureWindowFromSettings(w, appConfig);
  w.show();

  std::unique_ptr<ImageSelector> selector = GetSelectorForApp(appConfig);
  
  ImageSwitcher switcher(w, appConfig.rotationSeconds * 1000, selector);
  w.setImageSwitcher(&switcher);
  std::function<void(MainWindow &w, ImageSwitcher *switcher)> reloader = [&appConfig](MainWindow &w, ImageSwitcher *switcher) { ReloadConfigIfNeeded(appConfig, w, switcher); };
  switcher.setConfigFileReloader(reloader);

  std::unique_ptr<MqttController> mqttController;
  if (appConfig.mqtt.enabled)
  {
    mqttController = std::unique_ptr<MqttController>(new MqttController(appConfig.mqtt, &a));
    QObject::connect(mqttController.get(), &MqttController::play, [&switcher]() { switcher.resume(); });
    QObject::connect(mqttController.get(), &MqttController::pause, [&switcher]() { switcher.pause(); });
    QObject::connect(mqttController.get(), &MqttController::nextImage, [&switcher]() { switcher.stepOnce(); });
    QObject::connect(mqttController.get(), &MqttController::nextFolder, [&switcher]() {
      if (!switcher.skipToNextFolder())
        switcher.stepOnce();
    });
    QObject::connect(mqttController.get(), &MqttController::restart, [&appConfig, &switcher]() {
      std::unique_ptr<ImageSelector> newSelector = GetSelectorForApp(appConfig);
      switcher.restart(newSelector);
    });
    QObject::connect(mqttController.get(), &MqttController::immichControl, [&appConfig, &switcher](const QString &payload) {
      bool updated = false;
      for (int i = 0; i < appConfig.paths.count(); ++i)
      {
        if (!appConfig.paths[i].immich.enabled)
          continue;
        ImmichConfig newConfig = appConfig.paths[i].immich;
        if (ApplyImmichPayload(newConfig, payload))
        {
          appConfig.paths[i].immich = newConfig;
          updated = true;
        }
      }
      if (updated)
      {
        Log("MQTT immich update applied.");
        std::unique_ptr<ImageSelector> newSelector = GetSelectorForApp(appConfig);
        switcher.setImageSelector(newSelector);
        if (!switcher.isPaused())
          switcher.scheduleImageUpdate();
      }
      else
      {
        Log("MQTT immich update ignored: ", payload.toStdString());
      }
    });
    mqttController->start();
  }
  switcher.start();
  return a.exec();
}