/++
  native headers using<br>@title:<BR>:subtitle:<BR>type tags<BR>
  extract native/orig header return associative array
+/
module sdp.ao_conf_make_meta_native;
template SiSUheaderExtractNative() {
  private import
    std.exception,
    std.regex,
    std.stdio,
    std.string,
    std.traits,
    std.typecons,
    std.utf,
    std.conv : to;
  private import
    sdp.ao_rgx,
    sdp.ao_defaults;
  struct HeaderDocMetadataAndMakeNativeToAA {
    mixin SiSUregisters;
    mixin SiSUrgxInitFlags;
    mixin SiSUrgxInit;
    auto rgx = Rgx();
    enum State { off, on }
    string hm, hs;
    auto header_metadata_and_make_aa(H,Me,Ma)(
      H  header,
      Me dochead_meta,
      Ma dochead_make
    )
    in {
      debug(asserts){
        static assert(is(typeof(header)       == string));
        static assert(is(typeof(dochead_meta) == string[string][string]));
        static assert(is(typeof(dochead_make) == string[string][string]));
      }
    }
    body {
      scope(exit) {
        destroy(header);
        destroy(dochead_meta);
        destroy(dochead_make);
      }
      if (auto t = header.match(rgx.native_header_main)) {
        char[][] header_obj_spl =
          (cast(char[]) header).split(rgx.line_delimiter_ws_strip);
        auto hm = to!string(t.captures[1]);
        if (hm.match(rgx.main_headers)) {
          foreach (line; header_obj_spl) {
            if (auto m = line.match(rgx.native_header_main)) {
              if (!empty(m.captures[2])) {
                if (hm == "creator") {
                  dochead_meta[hm]["author"] =
                    to!string(m.captures[2]);
                } else if (hm == "title") {
                  dochead_meta[hm]["main"] =
                    to!string(m.captures[2]);
                } else if (hm == "publisher") {
                  dochead_meta[hm]["name"] =
                    to!string(m.captures[2]);
                }
              }
            } else if (auto s = match(line, rgx.native_header_sub)) {
              if (!empty(s.captures[2])) {
                auto hs = to!string(s.captures[1]);
                if ((hm == "make" )
                && (dochead_make[hm])) {
                  switch (hm) {
                  case "make":
                    if (hs.match(rgx.native_subhead_make)) {
                      if (dochead_make[hm][hs]) {
                        dochead_make[hm][hs] = to!string(s.captures[2]);
                      }
                    } else {
                      writeln("not a valid header type:", hm, ":", hs);
                      destroy(hm);
                      destroy(hs);
                    }
                    break;
                  default:
                    break;
                  }
                } else if (dochead_meta[hm]) {
                  switch (hm) {
                  case "creator":
                    if (hs.match(rgx.native_subhead_creator)) {
                      if (dochead_meta[hm][hs]) {
                        dochead_meta[hm][hs] =
                          to!string(s.captures[2]);
                      }
                    } else {
                      writeln("not a valid header type:", hm, ":", hs);
                      destroy(hm);
                      destroy(hs);
                    }
                    break;
                  case "title":
                    if (hs.match(rgx.native_subhead_title)) {
                      if ((hs == "subtitle")
                      && (dochead_meta[hm]["sub"])) {
                        dochead_meta[hm]["sub"] =
                          to!string(s.captures[2]);
                      } else if (dochead_meta[hm][hs]) {
                        dochead_meta[hm][hs] =
                          to!string(s.captures[2]);
                      }
                    } else {
                      writeln("not a valid header type:", hm, ":", hs);
                      destroy(hm);
                      destroy(hs);
                    }
                    break;
                  case "rights":
                    if (hs.match(rgx.native_subhead_rights)) {
                      if (dochead_meta[hm][hs]) {
                        dochead_meta[hm][hs] =
                          to!string(s.captures[2]);
                      }
                    } else {
                      writeln("not a valid header type:", hm, ":", hs);
                      destroy(hm);
                      destroy(hs);
                    }
                    break;
                  case "date":
                    if (hs.match(rgx.native_subhead_date)) {
                      if (dochead_meta[hm][hs]) {
                        dochead_meta[hm][hs] =
                          to!string(s.captures[2]);
                      }
                    } else {
                      writeln("not a valid header type:", hm, ":", hs);
                      destroy(hm);
                      destroy(hs);
                    }
                    break;
                  case "original":
                    if (hs.match(rgx.native_subhead_original)) {
                      if (dochead_meta[hm][hs]) {
                        dochead_meta[hm][hs] =
                          to!string(s.captures[2]);
                      }
                    } else {
                      writeln("not a valid header type:", hm, ":", hs);
                      destroy(hm);
                      destroy(hs);
                    }
                    break;
                  case "classify":
                    if (hs.match(rgx.native_subhead_classify)) {
                      if (dochead_meta[hm][hs]) {
                        dochead_meta[hm][hs] =
                          to!string(s.captures[2]);
                      }
                    } else {
                      writeln("not a valid header type:", hm, ":", hs);
                      destroy(hm);
                      destroy(hs);
                    }
                    break;
                  case "identifier":
                    if (hs.match(rgx.native_subhead_identifier)) {
                      if (dochead_meta[hm][hs]) {
                        dochead_meta[hm][hs] =
                          to!string(s.captures[2]);
                      }
                    } else {
                      writeln("not a valid header type:", hm, ":", hs);
                      destroy(hm);
                      destroy(hs);
                    }
                    break;
                  case "notes":
                    if (hs.match(rgx.native_subhead_notes)) {
                      if (dochead_meta[hm][hs]) {
                        dochead_meta[hm][hs] =
                          to!string(s.captures[2]);
                      }
                    } else {
                      writeln("not a valid header type:", hm, ":", hs);
                      destroy(hm);
                      destroy(hs);
                    }
                    break;
                  case "publisher":
                    if (hs.match(rgx.native_subhead_publisher)) {
                      if (dochead_meta[hm][hs]) {
                        dochead_meta[hm][hs] =
                          to!string(s.captures[2]);
                      }
                    } else {
                      writeln("not a valid header type:", hm, ":", hs);
                      destroy(hm);
                      destroy(hs);
                    }
                    break;
                  case "links":
                    destroy(hm);
                    destroy(hs);
                    break;
                  default:
                    break;
                  }
                }
              }
            }
          }
        } else {
          writeln("not a valid header type:", hm);
        }
      }
      auto t = tuple(dochead_meta, dochead_make);
      static assert(t.length==2);
      return t;
    }
    private auto native_header_extract(L,Lo,O,T)(
      L                line,
      return ref Lo    line_occur,
      return ref O     an_object,
      return ref T     type
    ) {
      debug(asserts){
        static assert(is(typeof(line)       == char[]));
        static assert(is(typeof(line_occur) == int[string]));
        static assert(is(typeof(an_object)  == string[string]));
        static assert(is(typeof(type)       == int[string]));
      }
      if (line.matchFirst(rgx.native_header_make)) {   /+ matched header_make +/
        debug(header1) { /+ writeln(line); +/ }
        type["header"]      = State.on;
        type["header_make"] = State.on;
        type["header_meta"] = State.off;
        ++line_occur["header_make"];
        an_object["body_nugget"] ~= line ~= "\n";
      } else if (line.matchFirst(rgx.native_header)) { /+ matched header_metadata +/
        /+ (generic header match and not previously caught by header_make) +/
        debug(header1) { /+ writeln(line); +/ }
        type["header"]      = State.on;
        type["header_make"] = State.off;
        type["header_meta"] = State.on;
        ++line_occur["header_meta"];
        an_object["body_nugget"] ~= line ~= "\n";
      } else if (type["header_make"] == State.on
      && (line_occur["header_make"] > State.off)) {     /+ header_make flag set +/
        if (line.matchFirst(rgx.native_header_sub)) {  /+ sub-header +/
          debug(header1) { /+ writeln(line); +/ }
          ++line_occur["header_make"];
          an_object["body_nugget"] ~= line ~= "\n";
        }
      } else if (type["header_meta"] == State.on
      && (line_occur["header_meta"] > State.off)) {     /+ header_metadata flag set +/
        if (line.matchFirst(rgx.native_header_sub)) {  /+ sub-header +/
          debug(header1) { /+ writeln(line); +/ }
          ++line_occur["header_meta"];
          an_object["body_nugget"] ~= line ~= "\n";
        }
      }
      return an_object;
    }
    auto header_reset_states_common(Lo,O,T)(
      return ref Lo    line_occur,
      return ref O     an_object,
      return ref T     type
    ) {
      debug(asserts){
        static assert(is(typeof(line_occur) == int[string]));
        static assert(is(typeof(an_object)  == string[string]));
        static assert(is(typeof(type)       == int[string]));
      }
      line_occur["header_make"] = State.off;
      line_occur["header_meta"] = State.off;
      type["header"] = State.off;
      an_object.remove("body_nugget");
      an_object.remove("is");
      an_object.remove("attrib");
    }
    private auto headerNativeToAA(Hn)(Hn src_header) {
      debug(asserts){
        static assert(is(typeof(src_header) == char[]));
      }
      auto type = flags_type_init;
      type = [
       "header"          : State.off,
       "header_make"     : State.off,
       "header_meta"     : State.off,
      ];
      string[string] an_object;
      int[string] line_occur;
      auto dochead_make = make_aa;
      auto dochead_meta = meta_aa;
      auto set_header = HeaderDocMetadataAndMakeNativeToAA();
      char[][] source_header_arr =
        (cast(char[]) src_header).split(rgx.newline_eol_delimiter);
      foreach(header_line; source_header_arr) {
        if (auto m = header_line.matchFirst(rgx.comment)) {
          /+ matched comment +/
          debug(comment) {
          }
          header_reset_states_common(line_occur, an_object, type);
        } else if ((header_line.matchFirst(rgx.native_header))
        || (type["header_make"] == State.on
        && (line_occur["header_make"] > State.off))
        || (type["header_meta"] == State.on
        && (line_occur["header_meta"] > State.off))) {
          if (header_line.length == 0) {
            /+ header_make instructions (current line empty) +/
            auto dochead_metadata_and_make =
              set_header.header_metadata_and_make_aa(strip(an_object["body_nugget"]), dochead_meta, dochead_make);
            static assert(!isTypeTuple!(dochead_metadata_and_make));
            dochead_meta = dochead_metadata_and_make[0];
            dochead_make = dochead_metadata_and_make[1];
            header_reset_states_common(line_occur, an_object, type);
            type["header_make"] = State.off;
            type["header_meta"] = State.off;
            debug(headersdlang) {
              writeln(dochead_metadata_and_make);
            }
          } else {
            an_object = native_header_extract(header_line, line_occur, an_object, type);
          }
        }
      }
      auto t = tuple(
        dochead_make,
        dochead_meta,
      );
      return t;
    }
  }
}