#include "sass.hpp"

#include <string>

#include <sstream>

#include <iostream>

#include <iomanip>

#include "ast.hpp"

#include "json.hpp"

#include "context.hpp"

#include "position.hpp"

#include "source_map.hpp"

namespace Sass {

  SourceMap::SourceMap() : current_position(0, 0, 0), file("stdin") { }

  SourceMap::SourceMap(const std::string& file) : current_position(0, 0, 0), file(file) { }

  std::string SourceMap::render_srcmap(Context &ctx) {

    const bool include_sources = ctx.c_options.source_map_contents;

    const std::vector<std::string> links = ctx.srcmap_links;

    const std::vector<Resource>& sources(ctx.resources);

    JsonNode* json_srcmap = json_mkobject();

    json_append_member(json_srcmap, "version", json_mknumber(3));

    const char *file_name = file.c_str();

    JsonNode *json_file_name = json_mkstring(file_name);

    json_append_member(json_srcmap, "file", json_file_name);

    // pass-through sourceRoot option

    if (!ctx.source_map_root.empty()) {

      JsonNode* root = json_mkstring(ctx.source_map_root.c_str());

      json_append_member(json_srcmap, "sourceRoot", root);

    }

    JsonNode *json_sources = json_mkarray();

    for (size_t i = 0; i < source_index.size(); ++i) {

      std::string source(links[source_index[i]]);

      if (ctx.c_options.source_map_file_urls) {

        source = File::rel2abs(source);

        // check for windows abs path

        if (source[0] == '/') {

          // ends up with three slashes

          source = "file://" + source;

        } else {

          // needs an additional slash

          source = "file:///" + source;

        }

      }

      const char* source_name = source.c_str();

      JsonNode *json_source_name = json_mkstring(source_name);

      json_append_element(json_sources, json_source_name);

    }

    json_append_member(json_srcmap, "sources", json_sources);

    if (include_sources && source_index.size()) {

      JsonNode *json_contents = json_mkarray();

      for (size_t i = 0; i < source_index.size(); ++i) {

        const Resource& resource(sources[source_index[i]]);

        JsonNode *json_content = json_mkstring(resource.contents);

        json_append_element(json_contents, json_content);

      }

      json_append_member(json_srcmap, "sourcesContent", json_contents);

    }

    JsonNode *json_names = json_mkarray();

    // so far we have no implementation for names

    // no problem as we do not alter any identifiers

    json_append_member(json_srcmap, "names", json_names);

    std::string mappings = serialize_mappings();

    JsonNode *json_mappings = json_mkstring(mappings.c_str());

    json_append_member(json_srcmap, "mappings", json_mappings);

    char *str = json_stringify(json_srcmap, "\t");

    std::string result = std::string(str);

    free(str);

    json_delete(json_srcmap);

    return result;

  }

  std::string SourceMap::serialize_mappings() {

    std::string result = "";

    size_t previous_generated_line = 0;

    size_t previous_generated_column = 0;

    size_t previous_original_line = 0;

    size_t previous_original_column = 0;

    size_t previous_original_file = 0;

    for (size_t i = 0; i < mappings.size(); ++i) {

      const size_t generated_line = mappings[i].generated_position.line;

      const size_t generated_column = mappings[i].generated_position.column;

      const size_t original_line = mappings[i].original_position.line;

      const size_t original_column = mappings[i].original_position.column;

      const size_t original_file = mappings[i].original_position.file;

      if (generated_line != previous_generated_line) {

        previous_generated_column = 0;

        if (generated_line > previous_generated_line) {

          result += std::string(generated_line - previous_generated_line, ';');

          previous_generated_line = generated_line;

        }

      }

      else if (i > 0) {

        result += ",";

      }

      // generated column

      result += base64vlq.encode(static_cast<int>(generated_column) - static_cast<int>(previous_generated_column));

      previous_generated_column = generated_column;

      // file

      result += base64vlq.encode(static_cast<int>(original_file) - static_cast<int>(previous_original_file));

      previous_original_file = original_file;

      // source line

      result += base64vlq.encode(static_cast<int>(original_line) - static_cast<int>(previous_original_line));

      previous_original_line = original_line;

      // source column

      result += base64vlq.encode(static_cast<int>(original_column) - static_cast<int>(previous_original_column));

      previous_original_column = original_column;

    }

    return result;

  }

  void SourceMap::prepend(const OutputBuffer& out)

  {

    Offset size(out.smap.current_position);

    for (Mapping mapping : out.smap.mappings) {

      if (mapping.generated_position.line > size.line) {

        throw(std::runtime_error("prepend sourcemap has illegal line"));

      }

      if (mapping.generated_position.line == size.line) {

        if (mapping.generated_position.column > size.column) {

          throw(std::runtime_error("prepend sourcemap has illegal column"));

        }

      }

    }

    // will adjust the offset

    prepend(Offset(out.buffer));

    // now add the new mappings

    VECTOR_UNSHIFT(mappings, out.smap.mappings);

  }

  void SourceMap::append(const OutputBuffer& out)

  {

    append(Offset(out.buffer));

  }

  void SourceMap::prepend(const Offset& offset)

  {

    if (offset.line != 0 || offset.column != 0) {

      for (Mapping& mapping : mappings) {

        // move stuff on the first old line

        if (mapping.generated_position.line == 0) {

          mapping.generated_position.column += offset.column;

        }

        // make place for the new lines

        mapping.generated_position.line += offset.line;

      }

    }

    if (current_position.line == 0) {

      current_position.column += offset.column;

    }

    current_position.line += offset.line;

  }

  void SourceMap::append(const Offset& offset)

  {

    current_position += offset;

  }

  void SourceMap::add_open_mapping(const AST_Node_Ptr node)

  {

    mappings.push_back(Mapping(node->pstate(), current_position));

  }

  void SourceMap::add_close_mapping(const AST_Node_Ptr node)

  {

    mappings.push_back(Mapping(node->pstate() + node->pstate().offset, current_position));

  }

  ParserState SourceMap::remap(const ParserState& pstate) {

    for (size_t i = 0; i < mappings.size(); ++i) {

      if (

        mappings[i].generated_position.file == pstate.file &&

        mappings[i].generated_position.line == pstate.line &&

        mappings[i].generated_position.column == pstate.column

      ) return ParserState(pstate.path, pstate.src, mappings[i].original_position, pstate.offset);

    }

    return ParserState(pstate.path, pstate.src, Position(-1, -1, -1), Offset(0, 0));

  }

}