module dhtags.attrs.attribute;

import dhtags.utils.html;

import std..string : format, toLower;
import std.array : join;
import std.algorithm : map;
import std.typecons : Nullable, Typedef;
import std.conv : to;

alias BoolAttribute = Typedef!string;

struct HtmlAttribute {
   string name;
   string value;

   this(string name, string value) {
      this.name = name;
      this.value = value;
   }

   string toString() const {
      return format(q{%s="%s"}, name, value);
   }

   /**
    * Find if a value is allowed for attributes that define specific values
    */
   mixin template FindAllowedValue(Attr, bool ct = false) {
      template toSymbol(string name) {
         mixin(format(q{ enum allowedValue = Attr.%s; }, name));
      }

      bool isValueAllowed(int i = 0)() {
         static if (i < Attr.TValues.length) {
            enum allowedName = "_allowedValue" ~ i.to!string;
            static if (__traits(hasMember, Attr, allowedName)) {
               mixin toSymbol!allowedName;
               return (allowedValue == strValue.toLower) || isValueAllowed!(i + 1);
            } else {
               return false || isValueAllowed!(i + 1);
            }
         } else {
            return false;
         }
      }

      auto findAllowedValue() {
         auto msg = format("'%s' is not a defined value for %s (must be one of the following: %s)", attr.value.to!string, Attr.stringof, Attr.TValues.stringof);
         static if (ct) {
            static assert(isValueAllowed, msg);
         } else {
            assert(isValueAllowed, msg);
         }

         return HtmlAttribute(attr.name, strValue.escape);
      }
   }

   /** 
    * Convert an attribute value to a string
    */
   mixin template ConvertToString(TVal, bool ct = false) {
      import std.traits : isSomeString, isArray;

      auto convertToString() {
         static if (is(TVal == BoolAttribute)) {
            if (attr.value) {
               return HtmlAttribute(attr.name, attr.name);
            }
         } else static if (!isSomeString!TVal && isArray!TVal && !typeof(attr).hasCustomAttr) {
            return HtmlAttribute(attr.name, attr.value.map!(x => asString!x).join(" ").escape);
         } else {
            return HtmlAttribute(attr.name, strValue.escape);
         }

         assert(false, format("Could not convert value for attribute %s to string", attr.name));
      }
   }

   /**
    * Creates an HtmlAttribute from an AttrPair
    */
   static auto create(alias attr)() {
      Nullable!(typeof(this)) result;
      string strValue;

      if (__ctfe) {
         enum value = attr.value;
         strValue = asString!(value);
      } else {
         strValue = attr.value.to!string;
      }

      // If the value's type is one of the attribute's defined types then we can convert it directly to a string
      static if (attr.valueTypeIsDefined) {
         mixin ConvertToString!(typeof(attr.value), true);
         result = convertToString;
      // Otherwise we'll check if the attribute defines a specific value that is allowed
      } else {
         mixin FindAllowedValue!(typeof(attr).AttrType, true);
         result = findAllowedValue;
      }

      return result;
   }

   static auto create(AttrPair)(AttrPair attr) {
      // TODO: Convert double to string at compile-time
      string strValue = attr.value.to!string;

      static if (typeof(attr).valueTypeIsDefined) {
         mixin ConvertToString!(typeof(attr.value), false);
         return convertToString;
      } else {
         mixin FindAllowedValue!(typeof(attr).AttrType, false);
         return findAllowedValue;
      }
   }
}

abstract class Attr {
   HtmlAttribute create();
}

class AttrPair(TAttr, TVal) : Attr {
   alias AttrType = TAttr;

   immutable string name;
   const TVal value;

   this(string name, TVal value) {
      this.name = name.camelCaseToHyphens.underscoreToHyphens;
      this.value = value;
   }

   /**
    * Create an HtmlAttribute from an AttrPair.
    */
   override HtmlAttribute create() {
      return HtmlAttribute.create(this);
   }

   /**
    * Checks if the type of this pair's value is one of the types defined by the actual attribute.
    */
   static bool valueTypeIsDefined(int i = 0)() {
      static if (__traits(hasMember, AttrType, "TValues")) {
         alias types = AttrType.TValues;

         static if (i < types.length) {
            static if (is(types[i] == BoolAttribute)) {
               // We always allow boolean attributes to pass since we know the underlying type is a string
               // (e.g. async="async")
               return true || valueTypeIsDefined!(i + 1);
            } else static if (!__traits(compiles, typeof(types[i]))) {
               return (is(types[i] == TVal)) || valueTypeIsDefined!(i + 1);
            } else {
               return false || valueTypeIsDefined!(i + 1);
            }
         } else {
            return false;
         }
      } else {
         // If value types are not defined then assume any type is allowed.
         return true;
      }
   }

   /**
    * Check if this pair was created from a user-defined attribute.
    */
   static bool hasCustomAttr() { 
      return is(AttrType : CustomAttribute);
   }
}

/** 
 * Represents a custom attribute created using 'attr' function, e.g. "my-attribute".attr
 */
struct CustomAttribute {
   immutable string name;

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

   enum opAssign(TVal)(TVal value) {
      return new AttrPair!(typeof(this), TVal)(name, value);
   }
}

/**
 * Represents a formatted attribute. e.g. 'data-%s' or 'aria-%s'
 */
struct FmtAttribute {
   this(string formatName) {
      this.formatName = formatName;
   }

   auto ref opCall(string name) {
      return CustomAttribute(format(formatName, name));
   }

   auto ref opDispatch(string name, TVal)(TVal val) {
      return CustomAttribute(format(formatName, name)) = val;
   }

   private {
      immutable string formatName;
   }
}