#include "vnode.h"
#include <ruby.h>
#include <ruby/encoding.h>
#include <ruby/re.h>

rb_encoding *utf8_encoding;

static ID id_checked;
static ID id_children;
static ID id_class;
static ID id_class_name;
static ID id_class_name2;
static ID id_context_id;
static ID id_context_type;
static ID id_dangerously_set_inner_html;
static ID id_default_checked;
static ID id_default_selected;
static ID id_default_value;
static ID id_development;
static ID id_downcase;
static ID id_encode_entities;
static ID id_eqeq;
static ID id_for;
static ID id_get_child_context;
static ID id_get_derived_state_from_props;
static ID id_gsub;
static ID id_html_for;

static ID id_key;
static ID id_keys;
static ID id_merge;
static ID id_props;
static ID id_ref;
static ID id_render;
static ID id_render_buffer;
static ID id_selected;
static ID id_self;
static ID id_source;
static ID id_style;
static ID id_style_obj_to_css;
static ID id_to_s;
static ID id_validate_props;
static ID id_value;

static ID iv_context;
static ID iv_declared_props;
static ID iv_next_state;
static ID iv_props;
static ID iv_state;

static char *str_aria = "aria-";
static char *str_data = "data-";
static char *str_foreign_object = "foreignObject";
static char *str_option = "option";
static char *str_select = "select";
static char *str_selected = "selected";
static char *str_svg = "svg";
static char *str_textarea = "textarea";

static char *str_rve =
    "^(area|base|br|col|embed|hr|img|input|link|meta|param|source|track|wbr)$";
static char *str_run = "[\\s\\n\\\\\\/='\"\\0<>]";
static char *str_rxl = "^xlink:?.";
static char *str_rx2 = "^xlink:?";
// static char *str_ree = "[\"&<]";

static VALUE s_false;
static VALUE s_true;
static VALUE s_xlink;

static VALUE sym_children;
static VALUE sym_class;
static VALUE sym_default;
static VALUE sym_for;
static VALUE sym_html;
static VALUE sym_key;
static VALUE sym_ref;
static VALUE sym_selected;
static VALUE sym_value;

static VALUE mIsomorfeus;
static VALUE mPreact;
static VALUE cFragment;

extern VALUE cVNode;

static VALUE rXlink;
static VALUE rUnsafe;
static VALUE rVoid;
static VALUE rXlink2;

static int set_default_prop_value(VALUE prop, VALUE value, VALUE props) {
  VALUE def_val = rb_hash_lookup(value, sym_default);
  if ((def_val != Qnil) && (rb_hash_lookup(props, prop) == Qnil))
    rb_hash_aset(props, prop, def_val);
  return 0;
}

static ID normalize_prop_name(ID name_id, VALUE is_svg_mode) {
  if (name_id == id_class_name || name_id == id_class_name2)
    return id_class;
  if (name_id == id_html_for)
    return id_for;
  if (name_id == id_default_value)
    return id_value;
  if (name_id == id_default_checked)
    return id_checked;
  if (name_id == id_default_selected)
    return id_selected;
  if (is_svg_mode == Qtrue) {
    VALUE name_s = rb_id2str(name_id);
    if (rb_reg_match(rXlink, name_s) == Qtrue) {
      name_s = rb_funcall(name_s, id_downcase, 0);
      name_s = rb_funcall(name_s, id_gsub, 2, rXlink2, s_xlink);
      return rb_intern_str(name_s);
    }
  }
  return name_id;
}

static VALUE normalize_prop_value(ID name_id, VALUE name_s, VALUE value,
                                  VALUE self) {
  if (name_id == id_style && TYPE(value) == T_HASH)
    return rb_funcall(self, id_style_obj_to_css, 1, value);
  if (value == Qtrue && RSTRING_LEN(name_s) > 4) {
    if ((0 == strncmp(RSTRING_PTR(name_s), str_aria, 5)) ||
        (0 == strncmp(RSTRING_PTR(name_s), str_data, 5))) {
      // always use string values instead of booleans for aria attributes
      // also see https://github.com/preactjs/preact/pull/2347/files
      return s_true;
    }
  }
  if (value == Qfalse && RSTRING_LEN(name_s) > 4) {
    if ((0 == strncmp(RSTRING_PTR(name_s), str_aria, 5)) ||
        (0 == strncmp(RSTRING_PTR(name_s), str_data, 5))) {
      // always use string values instead of booleans for aria attributes
      // also see https://github.com/preactjs/preact/pull/2347/files
      return s_false;
    }
  }
  return value;
}

static VALUE get_context(VALUE node_type, VALUE context) {
  VALUE ctx_type = rb_funcall(node_type, id_context_type, 0);
  if (ctx_type != Qnil) {
    VALUE provider =
        rb_hash_lookup(context, rb_funcall(ctx_type, id_context_id, 0));
    if (provider != Qnil)
      return rb_hash_lookup(rb_funcall(provider, id_props, 0), sym_value);
    else
      return rb_funcall(ctx_type, id_value, 0);
  }
  return context;
}

static VALUE render_class_component(VALUE vnode, VALUE context, VNode *v) {
  VALUE node_type = v->type;
  VALUE props = v->props;

  // get context
  VALUE cctx = get_context(node_type, context);

  // validate props
  VALUE declared_props = rb_ivar_get(node_type, iv_declared_props);
  if (declared_props != Qnil) {
    rb_hash_foreach(declared_props, set_default_prop_value, props);
    if (rb_funcall(mIsomorfeus, id_development, 0) == Qtrue)
      rb_funcall(node_type, id_validate_props, 1, props);
  }

  // freeze props
  rb_obj_freeze(props);

  // instantiate component
  const VALUE cargs[2] = {props, cctx};
  VALUE c = rb_class_new_instance(2, (const VALUE *)&cargs, node_type);
  v->component = c;

  // set state, props, context
  rb_ivar_set(c, iv_props, props);
  if (rb_ivar_get(c, iv_state) == Qnil)
    rb_ivar_set(c, iv_state, rb_hash_new());
  if (rb_ivar_get(c, iv_next_state) == Qnil)
    rb_ivar_set(c, iv_next_state, rb_ivar_get(c, iv_state));
  rb_ivar_set(c, iv_context, cctx);

  // get_derived_state_from_props
  if (rb_respond_to(c, id_get_derived_state_from_props)) {
    VALUE state = rb_ivar_get(c, iv_state);
    VALUE res = rb_funcall(c, id_get_derived_state_from_props, 2,
                           rb_funcall(c, id_props, 0), state);
    rb_ivar_set(c, iv_state, rb_funcall(state, id_merge, res));
  }

  // freeze state
  rb_obj_freeze(rb_ivar_get(c, iv_state));

  // render
  return rb_funcall(c, id_render, 0);
}

void internal_render_to_string(VALUE vnode, VALUE context, VALUE is_svg_mode,
                               VALUE select_value, VALUE self, VALUE rres) {
  size_t i, len;

  if (vnode == Qnil || vnode == Qfalse || vnode == Qtrue)
    return;

  switch (TYPE(vnode)) {
  case T_STRING:
    if (RSTRING_LEN(vnode) == 0)
      return;
    rb_str_buf_append(rres, rb_funcall(self, id_encode_entities, 1, vnode));
    return;
  case T_FIXNUM:
  case T_BIGNUM:
    rb_str_buf_append(rres, rb_funcall(vnode, id_to_s, 0));
    return;
  case T_ARRAY:
    len = RARRAY_LEN(vnode);
    for (i = 0; i < len; i++) {
      internal_render_to_string(RARRAY_PTR(vnode)[i], context, is_svg_mode,
                                select_value, self, rres);
    }
    return;
  }

  VNode *v = (VNode *)DATA_PTR(vnode);
  VALUE node_type = v->type;
  VALUE props = v->props;

  if (TYPE(node_type) != T_STRING) {
    // Components and Fragments
    VALUE rendered = Qnil;

    if (node_type == cFragment && RHASH_SIZE(props) > 0) {
      rendered = rb_hash_lookup(props, sym_children);
    } else {
      rendered = render_class_component(vnode, context, v);

      VALUE component = v->component;
      if (rb_respond_to(component, id_get_child_context)) {
        context = rb_funcall(context, id_merge, 1,
                             rb_funcall(component, id_get_child_context, 0));
      }
    }

    internal_render_to_string(rendered, context, is_svg_mode, select_value,
                              self, rres);
    return;
  }

  // render JSX to HTML
  rb_str_cat(rres, "<", 1);
  rb_str_buf_append(rres, node_type);

  VALUE children = Qnil;
  VALUE html = Qnil;

  if (props != Qnil && RHASH_SIZE(props) > 0) {
    children = rb_hash_lookup(props, sym_children);
    VALUE attrs = rb_funcall(props, id_keys, 0);
    len = RARRAY_LEN(attrs);
    for (i = 0; i < len; i++) {
      VALUE name = RARRAY_PTR(attrs)[i];
      ID name_id = SYM2ID(name);
      VALUE value = rb_hash_lookup(props, rb_to_symbol(name));

      if (name_id == id_key || name_id == id_ref || name_id == id_self ||
          name_id == id_source || name_id == id_children ||
          ((name_id == id_class_name || name_id == id_class_name2) &&
           (rb_hash_lookup(props, sym_class) != Qnil)) ||
          ((name_id == id_html_for) &&
           (rb_hash_lookup(props, sym_for) != Qnil)))
        continue;

      VALUE orig_name_id = name_id;
      VALUE name_s = rb_id2str(name_id);
      if (rb_reg_match(rUnsafe, name_s) == Qtrue)
        continue;

      name_id = normalize_prop_name(name_id, is_svg_mode);
      if (name_id != orig_name_id)
        name_s = rb_id2str(name_id);
      value = normalize_prop_value(name_id, name_s, value, self);

      if (name_id == id_dangerously_set_inner_html && value != Qnil) {
        html = rb_hash_lookup(value, sym_html);
      } else if (name_id == id_value &&
                 strcmp(RSTRING_PTR(node_type), str_textarea) == 0) {
        // <textarea value="a&b"> --> <textarea>a&amp;b</textarea>
        children = value;
      } else if (value != Qnil && value != Qfalse &&
                 rb_obj_is_proc(value) != Qtrue) {
        if (value == Qtrue ||
            ((TYPE(value) == T_STRING) && (RSTRING_PTR(value)[0] == 0))) {
          // if (name_id == id_class || name_id == id_style) { continue; }
          value = name_s;
          rb_str_cat(rres, " ", 1);
          rb_str_buf_append(rres, name_s);
          continue;
        }

        if (name_id == id_value) {
          if (strcmp(RSTRING_PTR(node_type), str_select) == 0) {
            select_value = value;
            continue;
          } else if (
              // If we're looking at an <option> and it's the currently selected
              // one
              strcmp(RSTRING_PTR(node_type), str_option) == 0 &&
              rb_funcall(select_value, id_eqeq, 1, value) == Qtrue &&
              // and the <option> doesn't already have a selected attribute on
              // it
              rb_hash_lookup(props, sym_selected) == Qnil) {
            rb_str_cat(rres, " ", 1);
            rb_str_cat(rres, str_selected, strlen(str_selected));
          }
        }

        rb_str_cat(rres, " ", 1);
        rb_str_buf_append(rres, name_s);
        rb_str_cat(rres, "=\"", 2);
        rb_str_buf_append(rres, rb_funcall(self, id_encode_entities, 1, rb_funcall(value, id_to_s, 0)));
        rb_str_cat(rres, "\"", 1);
      }
    }
  }

  rb_str_cat(rres, ">", 1);

  if (rb_reg_match(rUnsafe, node_type) == Qtrue)
    rb_raise(rb_eRuntimeError, "%s is not a valid HTML tag name in %s",
             RSTRING_PTR(node_type), RSTRING_PTR(rres));

  VALUE has_children = Qfalse;
  int children_type = (children == Qnil) ? T_NIL : TYPE(children);

  if (html != Qnil) {
    rb_str_buf_append(rres, html);
    has_children = Qtrue;
  } else if (children_type == T_STRING) {
    rb_str_buf_append(rres, rb_funcall(self, id_encode_entities, 1, children));
    has_children = Qtrue;
  } else if (children_type == T_ARRAY) {
    VALUE child;
    len = RARRAY_LEN(children);
    if (len > 0) {
      long rres_len;
      for (i = 0; i < len; i++) {
        child = RARRAY_PTR(children)[i];
        if (child != Qnil && child != Qfalse) {
          VALUE child_svg_mode;
          if (strcmp(RSTRING_PTR(node_type), str_svg) == 0)
            child_svg_mode = Qtrue;
          else if (strcmp(RSTRING_PTR(node_type), str_foreign_object) == 0 &&
                   is_svg_mode == Qtrue)
            child_svg_mode = Qfalse;
          else
            child_svg_mode = is_svg_mode;
          rres_len = RSTRING_LEN(rres);
          internal_render_to_string(child, context, child_svg_mode,
                                    select_value, self, rres);
          if (rres_len < RSTRING_LEN(rres))
            has_children = Qtrue;
        }
      }
    }
  } else if (children != Qnil && children != Qfalse && children != Qtrue) {
    VALUE child_svg_mode;
    if (strcmp(RSTRING_PTR(node_type), str_svg) == 0)
      child_svg_mode = Qtrue;
    else if (strcmp(RSTRING_PTR(node_type), str_foreign_object) == 0 &&
             is_svg_mode == Qtrue)
      child_svg_mode = Qfalse;
    else
      child_svg_mode = is_svg_mode;
    long rres_len = RSTRING_LEN(rres);
    internal_render_to_string(children, context, child_svg_mode, select_value,
                              self, rres);
    if (rres_len < RSTRING_LEN(rres))
      has_children = Qtrue;
  }

  if (has_children == Qfalse && rb_reg_match(rVoid, node_type) == Qtrue) {
    char l = RSTRING_PTR(rres)[RSTRING_LEN(rres) - 1];
    if (l == '>') {
      rb_str_set_len(rres, RSTRING_LEN(rres) - 1);
      rb_str_cat(rres, " />", 3);
    }
    return;
  }

  rb_str_cat(rres, "</", 2);
  rb_str_buf_append(rres, node_type);
  rb_str_cat(rres, ">", 1);

  return;
}

static VALUE render_to_string(int argc, VALUE *argv, VALUE self) {
  if (argc != 2)
    rb_raise(rb_eArgError,
             "wrong argument count, required args: vnode, context");
  VALUE vnode = argv[0];
  VALUE context = argv[1];
  if (context == Qnil)
    context = rb_hash_new();
  VALUE res = rb_enc_str_new("", 0, utf8_encoding);
  internal_render_to_string(vnode, context, Qfalse, Qnil, self, res);
  return res;
}

static VALUE is_renderable_q(VALUE self, VALUE block_result) {
  switch (TYPE(block_result)) {
  case T_BIGNUM:
  case T_FIXNUM:
  case T_FLOAT:
  case T_STRING:
    return Qtrue;
  case T_ARRAY:
    if (RARRAY_LEN(block_result) > 0)
      return is_renderable_q(self, RARRAY_PTR(block_result)[0]);
    return Qfalse;
  case T_DATA:
    if (RBASIC_CLASS(block_result) == cVNode)
      return Qtrue;
    return Qfalse;
  default:
    return Qfalse;
  }
  return Qfalse;
}

static VALUE create_element(int argc, VALUE *argv, VALUE self) {
  if (argc < 1 || argc > 3)
    rb_raise(rb_eArgError, "wrong argument count, required arg: type, optional "
                           "args: props, children");
  VALUE type = argv[0];
  VALUE props = (argc > 1) ? argv[1] : Qnil;
  VALUE children = (argc > 2) ? argv[2] : Qnil;
  VALUE normalized_props, key = Qnil, ref = Qnil;

  if (props != Qnil) {
    if (TYPE(props) == T_HASH) {
      normalized_props = rb_hash_dup(props);
      if (RHASH_SIZE(normalized_props) > 0) {
        key = rb_hash_delete(normalized_props, sym_key);
        ref = rb_hash_delete(normalized_props, sym_ref);
      }
    } else {
      children = props;
      normalized_props = rb_hash_new();
    }
  } else {
    normalized_props = rb_hash_new();
  }

  if (rb_block_given_p()) {
    VALUE pr = rb_funcall(mPreact, id_render_buffer, 0);
    rb_ary_push(pr, rb_ary_new());
    VALUE block_result = rb_yield(Qnil);
    VALUE c = rb_ary_pop(pr);
    if (is_renderable_q(mPreact, block_result) == Qtrue)
      rb_ary_push(c, block_result);
    if (RARRAY_LEN(c) > 0)
      children = c;
  }

  if (children != Qnil)
    rb_hash_aset(normalized_props, sym_children, children);

  const VALUE args[4] = {type, normalized_props, key, ref};
  return rb_class_new_instance(4, (const VALUE *)&args, cVNode);
}

static VALUE render_element(int argc, VALUE *argv, VALUE self) {
  VALUE pr = rb_funcall(self, id_render_buffer, 0);
  rb_ary_push(RARRAY_PTR(pr)[RARRAY_LEN(pr) - 1], create_element(argc, argv, self));
  return Qnil;
}

void Init_Preact(void) {
  utf8_encoding = rb_utf8_encoding();
  id_checked = rb_intern("checked");
  id_children = rb_intern("children");
  id_class = rb_intern("class");
  id_class_name = rb_intern("class_name");
  id_class_name2 = rb_intern("className");
  id_context_id = rb_intern("context_id");
  id_context_type = rb_intern("context_type");
  id_dangerously_set_inner_html = rb_intern("dangerouslySetInnerHTML");
  id_default_checked = rb_intern("default_checked");
  id_default_selected = rb_intern("default_selected");
  id_default_value = rb_intern("default_value");
  id_development = rb_intern("development?");
  id_downcase = rb_intern("downcase");
  id_encode_entities = rb_intern("_encode_entities");
  id_eqeq = rb_intern("==");
  id_for = rb_intern("for");
  id_get_child_context = rb_intern("get_child_context");
  id_get_derived_state_from_props = rb_intern("get_derived_state_from_props");
  id_gsub = rb_intern("gsub");
  id_html_for = rb_intern("html_for");
  id_key = rb_intern("key");
  id_keys = rb_intern("keys");
  id_merge = rb_intern("merge");
  id_props = rb_intern("props");
  id_ref = rb_intern("ref");
  id_render = rb_intern("render");
  id_render_buffer = rb_intern("render_buffer");
  id_selected = rb_intern("selected");
  id_self = rb_intern("__self");
  id_source = rb_intern("__source");
  id_style = rb_intern("style");
  id_style_obj_to_css = rb_intern("_style_obj_to_css");
  id_to_s = rb_intern("to_s");
  id_validate_props = rb_intern("validate_props");
  id_value = rb_intern("value");

  iv_context = rb_intern("@context");
  iv_declared_props = rb_intern("@declared_props");
  iv_next_state = rb_intern("@_nextState");
  iv_props = rb_intern("@props");
  iv_state = rb_intern("@state");

  sym_children = ID2SYM(rb_intern("children"));
  sym_class = ID2SYM(rb_intern("class"));
  sym_default = ID2SYM(rb_intern("default"));
  sym_for = ID2SYM(id_for);
  sym_html = ID2SYM(rb_intern("__html"));
  sym_key = ID2SYM(rb_intern("key"));
  sym_ref = ID2SYM(rb_intern("ref"));
  sym_selected = ID2SYM(rb_intern("selected"));
  sym_value = ID2SYM(id_value);

  mIsomorfeus = rb_const_get(rb_cObject, rb_intern("Isomorfeus"));
  mPreact = rb_define_module("Preact");
  cFragment = rb_define_class("Fragment", rb_cObject);

  // set instance variables on the module to keep references to these objects
  // to prevent garbage collection
  rUnsafe = rb_reg_regcomp(rb_str_new_cstr(str_run));
  rb_obj_freeze(rUnsafe);
  rb_ivar_set(mPreact, rb_intern("@_r_unsafe"), rUnsafe);
  rVoid = rb_reg_regcomp(rb_str_new_cstr(str_rve));
  rb_obj_freeze(rVoid);
  rb_ivar_set(mPreact, rb_intern("@_r_void"), rVoid);
  rXlink = rb_reg_regcomp(rb_str_new_cstr(str_rxl));
  rb_obj_freeze(rXlink);
  rb_ivar_set(mPreact, rb_intern("@_r_xlink"), rXlink);
  rXlink2 = rb_reg_regcomp(rb_str_new_cstr(str_rx2));
  rb_obj_freeze(rXlink2);
  rb_ivar_set(mPreact, rb_intern("@_r_xlink2"), rXlink2);

  s_false = rb_str_new_cstr("false");
  rb_obj_freeze(s_false);
  rb_ivar_set(mPreact, rb_intern("@_s_false"), s_false);
  s_true = rb_str_new_cstr("true");
  rb_obj_freeze(s_true);
  rb_ivar_set(mPreact, rb_intern("@_s_true"), s_true);
  s_xlink = rb_str_new_cstr("xlink:");
  rb_obj_freeze(s_xlink);
  rb_ivar_set(mPreact, rb_intern("@_s_xlink"), s_xlink);

  rb_define_module_function(mPreact, "_render_element", render_element, -1);
  rb_define_module_function(mPreact, "_render_to_string", render_to_string, -1);
  rb_define_module_function(mPreact, "create_element", create_element, -1);
  rb_define_module_function(mPreact, "is_renderable?", is_renderable_q, 1);
}