// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/modular/bin/sessionctl/session_ctl_app.h"

#include <lib/syslog/cpp/macros.h>

#include <regex>

#include "src/modular/bin/sessionctl/session_ctl_constants.h"

namespace modular {

SessionCtlApp::SessionCtlApp(fuchsia::modular::internal::BasemgrDebugPtr basemgr_debug,
                             fuchsia::modular::PuppetMasterPtr puppet_master,
                             fuchsia::sys::LoaderPtr sys_loader, const modular::Logger& logger,
                             async_dispatcher_t* const dispatcher)
    : basemgr_debug_(std::move(basemgr_debug)),
      puppet_master_(std::move(puppet_master)),
      sys_loader_(std::move(sys_loader)),
      logger_(logger),
      dispatcher_(dispatcher) {}

void SessionCtlApp::ExecuteCommand(std::string cmd, const fxl::CommandLine& command_line,
                                   CommandDoneCallback done) {
  if (cmd == kAddModCommandString) {
    ExecuteAddModCommand(command_line, std::move(done));
  } else if (cmd == kRemoveModCommandString) {
    ExecuteRemoveModCommand(command_line, std::move(done));
  } else if (cmd == kDeleteStoryCommandString) {
    ExecuteDeleteStoryCommand(command_line, std::move(done));
  } else if (cmd == kDeleteAllStoriesCommandString) {
    ExecuteDeleteAllStoriesCommand(std::move(done));
  } else if (cmd == kListStoriesCommandString) {
    ExecuteListStoriesCommand(std::move(done));
  } else if (cmd == kRestartSessionCommandString) {
    ExecuteRestartSessionCommand(std::move(done));
  } else {
    done(fit::error(""));
  }
}

void SessionCtlApp::ExecuteRemoveModCommand(const fxl::CommandLine& command_line,
                                            CommandDoneCallback done) {
  if (command_line.positional_args().size() == 1) {
    auto parsing_error = "Missing MOD_NAME. Ex: sessionctl remove_mod slider_mod";
    logger_.LogError(kRemoveModCommandString, parsing_error);
    done(fit::error(parsing_error));
    return;
  }

  // Get the mod name and default the story name to the mod name's hash
  std::string mod_name = command_line.positional_args().at(1);
  if (mod_name.find(":") == std::string::npos) {
    mod_name = fxl::StringPrintf(kFuchsiaPkgPath, mod_name.c_str(), mod_name.c_str());
  }
  std::string story_name = std::to_string(std::hash<std::string>{}(mod_name));

  // If the story_name flag isn't set, the story name will remain defaulted to
  // the mod name
  command_line.GetOptionValue(kStoryNameFlagString, &story_name);

  auto commands = MakeRemoveModCommands(mod_name);

  std::map<std::string, std::string> params = {{kModNameFlagString, mod_name},
                                               {kStoryNameFlagString, story_name}};

  puppet_master_->ControlStory(story_name, story_puppet_master_.NewRequest());
  PostTaskExecuteStoryCommand(kRemoveModCommandString, std::move(commands), params,
                              std::move(done));
}

void SessionCtlApp::ExecuteAddModCommand(const fxl::CommandLine& command_line,
                                         CommandDoneCallback done) {
  if (command_line.positional_args().size() == 1) {
    auto parsing_error = "Missing MOD_URL. Ex: sessionctl add_mod slider_mod";
    logger_.LogError(kAddModCommandString, parsing_error);
    done(fit::error(parsing_error));
    return;
  }

  // Get the mod url and default the mod name and story name to the mod url
  std::string mod_url = command_line.positional_args().at(1);

  if (mod_url.find("fuchsia-pkg://") != 0) {
    // |mod_url| is not a fuchsia-pkg URL. Continue without validating it.
    ExecuteAddModCommandInternal(mod_url, command_line, std::move(done));
    return;
  }

  ModPackageExists(
      mod_url, [this, mod_url, command_line, done = std::move(done)](bool exists) mutable {
        if (!exists) {
          done(fit::error(std::string("No package with URL " + mod_url + " was found")));
          return;
        }
        ExecuteAddModCommandInternal(mod_url, command_line, std::move(done));
      });
}

void SessionCtlApp::ExecuteAddModCommandInternal(std::string mod_url,
                                                 const fxl::CommandLine& command_line,
                                                 CommandDoneCallback done) {
  // If there's not a colon, resolve to the fuchsia package path
  if (mod_url.find(":") == std::string::npos) {
    mod_url = fxl::StringPrintf(kFuchsiaPkgPath, mod_url.c_str(), mod_url.c_str());
  }

  std::string mod_name = mod_url;
  std::string story_name = std::to_string(std::hash<std::string>{}(mod_url));

  if (command_line.HasOption(kStoryNameFlagString)) {
    command_line.GetOptionValue(kStoryNameFlagString, &story_name);
    // regex from src/sys/appmgr/realm.cc:168
    std::regex story_name_regex("[0-9a-zA-Z\\.\\-_:#]+");
    std::smatch story_name_match;
    if (!std::regex_search(story_name, story_name_match, story_name_regex)) {
      auto parsing_error = "Bad characters in story_name: " + story_name;
      logger_.LogError(kStoryNameFlagString, parsing_error);
      done(fit::error(parsing_error));
      return;
    }
  } else {
    std::cout << "Using auto-generated --story_name value of " << story_name << std::endl;
  }

  command_line.GetOptionValue(kModNameFlagString, &mod_name);
  if (!command_line.HasOption(kModNameFlagString)) {
    std::cout << "Using auto-generated --mod_name value of " << mod_name << std::endl;
  }

  auto commands = MakeAddModCommands(mod_url, mod_name);

  std::map<std::string, std::string> params = {{kModUrlFlagString, mod_url},
                                               {kModNameFlagString, mod_name},
                                               {kStoryNameFlagString, story_name}};

  puppet_master_->ControlStory(story_name, story_puppet_master_.NewRequest());
  PostTaskExecuteStoryCommand(kAddModCommandString, std::move(commands), params, std::move(done));
}

void SessionCtlApp::ExecuteDeleteStoryCommand(const fxl::CommandLine& command_line,
                                              CommandDoneCallback done) {
  if (command_line.positional_args().size() == 1) {
    auto parsing_error = "Missing STORY_NAME. Ex. sessionctl delete_story story";
    logger_.LogError(kStoryNameFlagString, parsing_error);
    done(fit::error(parsing_error));
    return;
  }

  // Get the story name
  std::string story_name = command_line.positional_args().at(1);

  std::map<std::string, std::string> params = {{kStoryNameFlagString, story_name}};
  async::PostTask(dispatcher_, [this, story_name, params, done = std::move(done)]() mutable {
    puppet_master_->GetStories([this, story_name, params, done = std::move(done)](
                                   std::vector<std::string> story_names) mutable {
      auto story_exists =
          std::find(story_names.begin(), story_names.end(), story_name) != story_names.end();
      if (!story_exists) {
        done(fit::error("Non-existent story_name " + story_name));
        return;
      }
      puppet_master_->DeleteStory(story_name, [done = std::move(done)] { done(fit::ok()); });
      logger_.Log(kDeleteStoryCommandString, params);
    });
  });
}

void SessionCtlApp::ExecuteDeleteAllStoriesCommand(CommandDoneCallback done) {
  async::PostTask(dispatcher_, [this, done = std::move(done)]() mutable {
    puppet_master_->GetStories(
        [this, done = std::move(done)](std::vector<std::string> story_names) mutable {
          struct BarrierState {
            int remaining;
            CommandDoneCallback done;
          };
          auto shared_state = std::make_shared<BarrierState>();
          shared_state->remaining = story_names.size();
          shared_state->done = std::move(done);
          for (auto story : story_names) {
            puppet_master_->DeleteStory(story, [shared_state] {
              --shared_state->remaining;
              if (shared_state->remaining == 0) {
                shared_state->done(fit::ok());
              }
            });
          }
          logger_.Log(kDeleteAllStoriesCommandString, std::move(story_names));
        });
  });
}

void SessionCtlApp::ExecuteListStoriesCommand(CommandDoneCallback done) {
  async::PostTask(dispatcher_, [this, done = std::move(done)]() mutable {
    puppet_master_->GetStories(
        [this, done = std::move(done)](std::vector<std::string> story_names) {
          logger_.Log(kListStoriesCommandString, std::move(story_names));
          done(fit::ok());
        });
  });
}

void SessionCtlApp::ExecuteRestartSessionCommand(CommandDoneCallback done) {
  basemgr_debug_->RestartSession([this, done = std::move(done)]() {
    logger_.Log(kRestartSessionCommandString, std::vector<std::string>());
    done(fit::ok());
  });
}

std::vector<fuchsia::modular::StoryCommand> SessionCtlApp::MakeAddModCommands(
    const std::string& mod_url, const std::string& mod_name) {
  fuchsia::modular::Intent intent;
  intent.handler = mod_url;

  std::vector<fuchsia::modular::StoryCommand> commands;
  fuchsia::modular::StoryCommand command;

  // Add command to add or update the mod (it will be updated if the mod_name
  // already exists in the story).
  fuchsia::modular::AddMod add_mod;
  add_mod.mod_name_transitional = mod_name;
  intent.Clone(&add_mod.intent);
  // TODO(fxbug.dev/16775): Sessionctl takes in inital intent and other fields.

  command.set_add_mod(std::move(add_mod));
  commands.push_back(std::move(command));

  return commands;
}

std::vector<fuchsia::modular::StoryCommand> SessionCtlApp::MakeRemoveModCommands(
    const std::string& mod_name) {
  std::vector<fuchsia::modular::StoryCommand> commands;
  fuchsia::modular::StoryCommand command;

  fuchsia::modular::RemoveMod remove_mod;
  remove_mod.mod_name_transitional = mod_name;
  command.set_remove_mod(std::move(remove_mod));
  commands.push_back(std::move(command));
  return commands;
}

void SessionCtlApp::PostTaskExecuteStoryCommand(
    const std::string command_name, std::vector<fuchsia::modular::StoryCommand> commands,
    std::map<std::string, std::string> params, CommandDoneCallback done) {
  async::PostTask(dispatcher_, [this, command_name, commands = std::move(commands), params,
                                done = std::move(done)]() mutable {
    ExecuteStoryCommand(std::move(commands), params.at(kStoryNameFlagString))
        ->Then([this, command_name, params, done = std::move(done)](bool has_error,
                                                                    std::string result) {
          if (has_error) {
            logger_.LogError(command_name, result);
            done(fit::error(result));
          } else {
            auto params_copy = params;
            params_copy.emplace(kStoryIdFlagString, result);
            logger_.Log(command_name, params_copy);
            done(fit::ok());
          }
        });
  });
}

modular::FuturePtr<bool, std::string> SessionCtlApp::ExecuteStoryCommand(
    std::vector<fuchsia::modular::StoryCommand> commands, const std::string& story_name) {
  story_puppet_master_->Enqueue(std::move(commands));

  auto fut = modular::Future<bool, std::string>::Create("Sessionctl StoryPuppetMaster::Execute");

  story_puppet_master_->Execute([fut](fuchsia::modular::ExecuteResult result) mutable {
    if (result.status == fuchsia::modular::ExecuteStatus::OK) {
      fut->Complete(false, result.story_id->c_str());
    } else {
      std::string error = fxl::StringPrintf("Puppet master returned status: %d and error: %s",
                                            (uint32_t)result.status, result.error_message->c_str());

      FX_LOGS(WARNING) << error << std::endl;
      fut->Complete(true, std::move(error));
    }
  });

  return fut;
}

void SessionCtlApp::ModPackageExists(std::string url, fit::function<void(bool)> done) {
  sys_loader_->LoadUrl(
      url, [done = std::move(done)](fuchsia::sys::PackagePtr package) { done(!!package); });
}

}  // namespace modular