/*
  *  MoMEMta: a modular implementation of the Matrix Element Method
  *  Copyright (C) 2016  Universite catholique de Louvain (UCL), Belgium
  *
  *  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 3 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, see <http://www.gnu.org/licenses/>.
  */
 
 #include <momemta/ModuleDefBuilder.h>
 
 #include <momemta/Logging.h>
 
 #include <ModuleDefUtils.h>
 #include <strings/Scanner.h>
 
 namespace momemta {
 namespace registration {
 
 namespace {
 
 class invalid_name: public std::runtime_error {
     using std::runtime_error::runtime_error;
 };
 
 class invalid_type: public std::runtime_error {
     using std::runtime_error::runtime_error;
 };
 
 class missing_attribute: public std::runtime_error {
     using std::runtime_error::runtime_error;
 };
 
 void finalizeInputOrOutput(StringPiece spec, bool is_output, ModuleRegistrationData& data) {
     using namespace strings;
 
     ArgDef def;
     StringPiece out;
 
     // An optional input starts with a '?'
 
     def.optional = spec.Consume("?");
 
     def.many = spec.Consume("*");
 
     if (! is_output) {
         // This can be a nested input declaration
         // Format is `<attr>/[<attr>/]*<name>`
         while (true) {
             if (! Scanner(spec)
                 .RestartCapture()
                 .ScanUntil('/')
                 .StopCapture()
                 .OneLiteral("/")
                 .GetResult(&spec, &out)) {
                 // No (more) match, exiting the loop
                 break;
             }
 
             auto nested_attribute = out.ToString();
 
             // Ensure attribute exists
             auto attr = momemta::findAttr(nested_attribute, data.module_def);
             if (! attr) {
                 std::string error = "Input definition for module " + data.module_def.name + " references a non-existing "
                             "attribute: " + nested_attribute;
                 LOG(fatal) << error;
                 throw missing_attribute(error);
             } else {
                 def.nested_attributes.push_back(*attr);
             }
         }
     }
 
     // Parse <name>
     if (!Scanner(spec)
             .One(Scanner::LETTER)
             .Any(Scanner::LETTER_DIGIT_UNDERSCORE)
             .StopCapture()
             .AnySpace()
             .GetResult(&spec, &out)) {
         throw invalid_name(std::string("Invalid ") +
                 ((is_output) ? "output" : "input") +
                 " name format (<name>:) for module " + data.module_def.name);
     }
 
     def.name = out.ToString();
 
     if (!is_output) {
         // Parse default value
         bool has_default = spec.Consume("=");
         if (has_default) {
             Scanner(spec)
                     .Any(Scanner::LETTER_DIGIT_UNDERSCORE_COLON)
                     .StopCapture()
                     .AnySpace()
                     .GetResult(&spec, &out);
 
             def.default_value = out.ToString();
             def.optional = true;
         }
     }
 
     if (is_output) {
         data.module_def.outputs.emplace_back(def);
     } else {
         data.module_def.inputs.emplace_back(def);
     }
 }
 
 void finalizeAttr(StringPiece spec, ModuleRegistrationData& data) {
     using namespace strings;
 
     AttrDef def;
 
     // A global attribute starts with a '^'.
     def.global = spec.Consume("^");
 
     // An optional attribute starts with '?'
     def.optional = spec.Consume("?");
 
     StringPiece out;
 
     // Parse `<name>:`
     if (! Scanner(spec)
             .One(Scanner::LETTER)
             .Any(Scanner::LETTER_DIGIT_UNDERSCORE)
             .StopCapture()
             .AnySpace()
             .OneLiteral(":")
             .AnySpace()
             .GetResult(&spec, &out)) {
         throw invalid_name("Invalid attribute name format (<name>:) for module " + data.module_def.name);
     }
 
     def.name = out.ToString();
 
     // Read "<type>" or "list(<type>)".
     bool is_list = Scanner(spec)
             .OneLiteral("list")
             .AnySpace()
             .OneLiteral("(")
             .AnySpace()
             .GetResult(&spec);
 
     // Consume type
     if (!Scanner(spec)
         .Any(Scanner::LOWERLETTER)
         .StopCapture()
         .AnySpace()
         .GetResult(&spec, &out)) {
         throw invalid_type("Invalid type format for attribute " + def.name + " for module " + data.module_def.name);
     }
 
     // TODO: Validate type against a list of acceptable types
 
     if (is_list) {
         def.type = "list(" + out.ToString() + ")";
     } else {
         def.type = out.ToString();
     }
 
     if (is_list) {
         spec.Consume(")");
     }
 
     // Check if there's a default value, and parse it
     if (spec.Consume("=")) {
         Scanner(spec)
             .Any(Scanner::LETTER_DIGIT_DASH_DOT_SLASH_UNDERSCORE)
             .StopCapture()
             .AnySpace()
             .GetResult(&spec, &out);
         def.default_value = out.ToString();
         def.optional = true;
     }
 
     data.module_def.attributes.emplace_back(def);
 }
 
 }
 
 ModuleDefBuilder::ModuleDefBuilder(const std::string& name) {
     reg_data.module_def.name = name;
 
     if (name.length() > 1 && name[0] == '_')
         reg_data.module_def.internal = true;
 }
 
 ModuleDefBuilder& ModuleDefBuilder::Input(const std::string& spec) {
     inputs.emplace_back(spec);
     return *this;
 }
 
 ModuleDefBuilder& ModuleDefBuilder::OptionalInput(const std::string& spec) {
     // Prefix spec with '?' to indicate an optional input
     inputs.emplace_back("?" + spec);
     return *this;
 }
 
 ModuleDefBuilder& ModuleDefBuilder::Inputs(const std::string& spec) {
     // Prefix spec with '*' to indicate a list of inputs
     inputs.emplace_back("*" + spec);
     return *this;
 }
 
 ModuleDefBuilder& ModuleDefBuilder::OptionalInputs(const std::string& spec) {
     // Prefix spec with '?*' to indicate optional inputs
     inputs.emplace_back("?*" + spec);
     return *this;
 }
 
 ModuleDefBuilder& ModuleDefBuilder::Output(const std::string& spec) {
     outputs.emplace_back(spec);
     return *this;
 }
 
 ModuleDefBuilder& ModuleDefBuilder::Attr(const std::string& spec) {
     attrs.emplace_back(spec);
     return *this;
 }
 
 ModuleDefBuilder& ModuleDefBuilder::GlobalAttr(const std::string& spec) {
     // Prefix spec with '^' to indicate a global attribute
     attrs.emplace_back("^" + spec);
     return *this;
 }
 
 ModuleDefBuilder& ModuleDefBuilder::OptionalAttr(const std::string& spec) {
     // Prefix spec with '?' to indicate an optional attribute
     attrs.emplace_back("?" + spec);
     return *this;
 }
 
 ModuleDefBuilder& ModuleDefBuilder::Sticky() {
     reg_data.module_def.sticky = true;
     return *this;
 }
 
 std::string ModuleDefBuilder::name() const {
     return reg_data.module_def.name;
 }
 
 ModuleRegistrationData ModuleDefBuilder::Build() const {
 
     auto data = reg_data;
 
     for (const auto& spec: attrs) {
         finalizeAttr(spec, data);
     }
 
     for (const auto& spec: inputs) {
         finalizeInputOrOutput(spec, false, data);
     }
 
     for (const auto& spec: outputs) {
         finalizeInputOrOutput(spec, true, data);
     }
 
     return data;
 }
 
 }
 }