#include "sass.hpp"

#include "sass.h"

#include "values.hpp"

#include <stdint.h>

namespace Sass {

  // convert value from C++ side to C-API

  union Sass_Value* ast_node_to_sass_value (const Expression_Ptr val)

  {

    if (val->concrete_type() == Expression::NUMBER)

    {

      Number_Ptr_Const res = Cast<Number>(val);

      return sass_make_number(res->value(), res->unit().c_str());

    }

    else if (val->concrete_type() == Expression::COLOR)

    {

      Color_Ptr_Const col = Cast<Color>(val);

      return sass_make_color(col->r(), col->g(), col->b(), col->a());

    }

    else if (val->concrete_type() == Expression::LIST)

    {

      List_Ptr_Const l = Cast<List>(val);

      union Sass_Value* list = sass_make_list(l->size(), l->separator());

      for (size_t i = 0, L = l->length(); i < L; ++i) {

        Expression_Obj obj = l->at(i);

        auto val = ast_node_to_sass_value(obj);

        sass_list_set_value(list, i, val);

      }

      return list;

    }

    else if (val->concrete_type() == Expression::MAP)

    {

      Map_Ptr_Const m = Cast<Map>(val);

      union Sass_Value* map = sass_make_map(m->length());

      size_t i = 0; for (Expression_Obj key : m->keys()) {

        sass_map_set_key(map, i, ast_node_to_sass_value(key));

        sass_map_set_value(map, i, ast_node_to_sass_value(m->at(key)));

        ++ i;

      }

      return map;

    }

    else if (val->concrete_type() == Expression::NULL_VAL)

    {

      return sass_make_null();

    }

    else if (val->concrete_type() == Expression::BOOLEAN)

    {

      Boolean_Ptr_Const res = Cast<Boolean>(val);

      return sass_make_boolean(res->value());

    }

    else if (val->concrete_type() == Expression::STRING)

    {

      if (String_Quoted_Ptr_Const qstr = Cast<String_Quoted>(val))

      {

        return sass_make_qstring(qstr->value().c_str());

      }

      else if (String_Constant_Ptr_Const cstr = Cast<String_Constant>(val))

      {

        return sass_make_string(cstr->value().c_str());

      }

    }

    return sass_make_error("unknown sass value type");

  }

  // convert value from C-API to C++ side

  Value_Ptr sass_value_to_ast_node (const union Sass_Value* val)

  {

    switch (sass_value_get_tag(val)) {

      case SASS_NUMBER:

        return SASS_MEMORY_NEW(Number,

                               ParserState("[C-VALUE]"),

                               sass_number_get_value(val),

                               sass_number_get_unit(val));

      case SASS_BOOLEAN:

        return SASS_MEMORY_NEW(Boolean,

                               ParserState("[C-VALUE]"),

                               sass_boolean_get_value(val));

      case SASS_COLOR:

        return SASS_MEMORY_NEW(Color,

                               ParserState("[C-VALUE]"),

                               sass_color_get_r(val),

                               sass_color_get_g(val),

                               sass_color_get_b(val),

                               sass_color_get_a(val));

      case SASS_STRING:

        if (sass_string_is_quoted(val)) {

          return SASS_MEMORY_NEW(String_Quoted,

                                 ParserState("[C-VALUE]"),

                                 sass_string_get_value(val));

        }

        return SASS_MEMORY_NEW(String_Constant,

                                 ParserState("[C-VALUE]"),

                                 sass_string_get_value(val));

      case SASS_LIST: {

        List_Ptr l = SASS_MEMORY_NEW(List,

                                  ParserState("[C-VALUE]"),

                                  sass_list_get_length(val),

                                  sass_list_get_separator(val));

        for (size_t i = 0, L = sass_list_get_length(val); i < L; ++i) {

          l->append(sass_value_to_ast_node(sass_list_get_value(val, i)));

        }

        return l;

      }

      case SASS_MAP: {

        Map_Ptr m = SASS_MEMORY_NEW(Map, ParserState("[C-VALUE]"));

        for (size_t i = 0, L = sass_map_get_length(val); i < L; ++i) {

          *m << std::make_pair(

            sass_value_to_ast_node(sass_map_get_key(val, i)),

            sass_value_to_ast_node(sass_map_get_value(val, i)));

        }

        return m;

      }

      case SASS_NULL:

        return SASS_MEMORY_NEW(Null, ParserState("[C-VALUE]"));

      case SASS_ERROR:

        return SASS_MEMORY_NEW(Custom_Error,

                               ParserState("[C-VALUE]"),

                               sass_error_get_message(val));

      case SASS_WARNING:

        return SASS_MEMORY_NEW(Custom_Warning,

                               ParserState("[C-VALUE]"),

                               sass_warning_get_message(val));

      default: break;

    }

    return 0;

  }

}