module dhtags.tags.tag;

import dhtags.tags.properties;
import dhtags.attrs.attribute : HtmlAttribute, Attr;
import dhtags.utils.html;
import dhtags.utils.prettyprint;

import std..string : format;
import std.array : array, join;
import std.range.primitives : isInputRange, ElementType;
import std.traits : isSomeString, isArray;

interface TagProperties {
   string name() const;
   string before() const;
   string open(string attrs) const;
   string close() const;
   bool isVoid() const;
}

interface HtmlFragment {
   string toString() const;
   string toString(bool escaped) const;
   string toPrettyString(bool escaped);

   mixin PrettyPrintFuncs;
}

/**
 * Bare-bones html tag with children and attributes.
 */
alias Tag = HtmlTag;
class HtmlTag : HtmlFragment {
   import std.algorithm : map, each;
   import std.conv : to;

   HtmlAttribute[] attrs;
   HtmlFragment[] children;

   override string toString() const {
      return toString(true);
   }

   /**
    * Generate an HTML string by iterating through all of the tag's children.
    */
   string toString(bool escaped) const {
      return
         tag.before ~
         tag.open(attrsToString) ~
         children.map!(x => x.toString(escaped)).join ~
         tag.close;
   }

   /**
    * Generate a pretty HTML string.
    */
   string toPrettyString(bool escaped = true) {
      import std.range : enumerate;

      auto hasOneString = children.length == 1 && isHtmlString(children[0]);
      if (hasOneString) {
         children[0].isOnlyChild = true;
      }

      auto newline = "\n";
      auto indent = createIndent.join;

      auto childIndent = (children.length) ? HtmlProperties.Indent : "";
      auto childNewline = children.length > 0 && !hasOneString;
      auto childLength = children.length;
      auto thisDepth = depth;

      return
         tag.before ~
         indent ~ // Indent opening tag to proper depth
         tag.open(attrsToString) ~ // Open tag with attributes
         ((childNewline) ? newline : "") ~ // Put children on new line if this tag has at least one child which is not a string
         children.enumerate.map!(x =>
            x.value
            .hasNextSibling(x.index != childLength - 1)
            .depth(thisDepth + 1)
            .toPrettyString(escaped)
         ).join ~
         ((childNewline) ? newline ~ indent : "") ~ // Put closing tag on indented new line to match opening tag
         tag.close ~ // Close tag
         ((hasNextSibling) ? newline : ""); // Put starting tag of next sibling on new line
   }

   protected {
      void createAttrs(AttrPairs...)(AttrPairs attrPairs) {
         import dhtags.utils.range : isAttrRange, isAttrArray;
         import std.algorithm : map;

         void iteratePairs(int i = 0)() {
            static if (i < attrPairs.length) {
               alias T = typeof(attrPairs[i]);

               static if (isAttrRange!(T)) {
                  attrs ~= (attrPairs[i])[].map!(x => x.create).array;
               } else static if (isAttrArray!(T)) {
                  foreach (x; attrPairs[i]) { attrs ~= x.create; }
               } else {
                  attrs ~= attrPairs[i].create;
               }

               iteratePairs!(i + 1);
            }
         }

         iteratePairs;
      }

      void setChildren(Children...)(Children c) {
         this.children = verifyChildren(c);

         if (tag.isVoid) {
            assert(children.length == 0, format("Void tag %s has %d children (should be 0)", tag.name, children.length));
         }
      }

      @property const(TagProperties) tag() const {
         assert(false, format("Tag for fragment '%s' not found", this.stringof));
      }

      string attrsToString() const { return attrs.map!(x => x.toString).join(" "); }
   }

   mixin PrettyPrintImpl;

   private {
      enum ChildType : string {
         FRAGMENT = "Fragment",
         FRAGMENT_RANGE = "FragmentRange",
         FRAGMENT_ARRAY = "FragmentArray",
         STRING = "string",
         BUILTIN = "built-in",
         UNKNOWN = "unknown"
      }

      /**
       * Verify that the tag's children are either tags, strings, or built-in types that can be converted to strings.
       */
      HtmlFragment[] verifyChildren(Children...)(Children children) {
         import std.traits : isBuiltinType;
         import dhtags.utils.range : isRange;

         HtmlFragment[] frags;

         foreach (c; children) {
            alias T = typeof(c);
            string type;

            static if (is(T : HtmlFragment) || is(T : const(HtmlFragment))) {
               frags ~= cast(HtmlFragment) c;
               type = ChildType.FRAGMENT;
            } else static if (isRange!(T) && !is(T : string)) {
               alias EType = ElementType!(T);

               static if (is(EType : HtmlFragment) || is(EType : const(HtmlFragment))) {
                  c.each!(x => frags ~= x);
               } else static if (is(EType : string)) {
                  c.each!(x => frags ~= new HtmlString(x));
               } else static if (isBuiltinType!(EType)) {
                  c.each!(x => frags ~= new HtmlString(x.to!string));
               } else {
                  static assert(false, format("Unknown array type %s found in %s", T.stringof, tag.name));
               }

               type = ChildType.FRAGMENT_RANGE;
            } else static if (isArray!(T) && !is(T : string)) {
               alias EType = ElementType!(T);

               static if (is(EType : HtmlFragment) || is(EType : const(HtmlFragment))) {
                  foreach (x; c) { frags ~= x; }
               } else static if (is(EType : string)) {
                  foreach (x; c) { frags ~= new HtmlString(x); }
               } else static if (isBuiltinType!(EType)) {
                  foreach (x; c) { frags ~= new HtmlString(x.to!string); }
               } else {
                  static assert(false, format("Unknown array type %s found in %s", T.stringof, tag.name));
               }

               type = ChildType.FRAGMENT_ARRAY;
            } else static if (is(T : string)) {
               frags ~= new HtmlString(c);
               type = ChildType.STRING;
            } else static if (isBuiltinType!(T)) {
               frags ~= new HtmlString(c.to!string);
               type = ChildType.BUILTIN;
            } else {
               static assert(false, format("Unknown tag %s found", T.stringof));
            }

            debug {
               // printChild(c, type);
            }
         }

         return frags;
      }

      bool isHtmlString(inout HtmlFragment frag) inout {
         return (cast(HtmlString) frag) !is null;
      }

      void print() {
         import std.stdio : writeln;
         debug {
            if (!__ctfe) {
               writeln("Tag: ", tag.name);
               writeln("Attributes: ", attrs);
               writeln("Children: ", children);
            }
         }
      }

      /**
       * Print child with its type
       */
      void printChild(T)(T child, string type = "") {
         if (!__ctfe) {
            import std.stdio : writeln;
            writeln(format("[%s -> %s]: ", T.stringof, type), child);
         }
      }
   }
}

/**
 * Wraps a string that appears inside a tag's contents.
 */
class HtmlString : HtmlFragment {
   string text;

   this(string text) {
      this.text = text;
   }

   override string toString() const {
      return toString(true);
   }

   string toString(bool escaped) const {
      return (escaped) ? text.escape : text;
   }

   string toPrettyString(bool escaped = true) {
      return (!isOnlyChild) ? createIndent.join ~ toString(escaped)  ~ "\n" : toString(escaped);
   }

   mixin PrettyPrintImpl;
}