// canvas::draw overridable
    virtual void draw( HELEMENT he, graphics& gx, UINT width, UINT height )
    { 
      if( !data.is_array() )
      {
        draw_message( gx, width, height, const_wchars(L"Data not found") );
        return; 
      }

      color black(0,0,0);

       // x axis
      gx.line_cap(LINE_CAP_BUTT);
      gx.line_color(black);
      gx.line( 0.5, height - 0.5, width - 0.5, height - 0.5 ); // 0.5 - to draw line in the middle of the pixel

      for( int n = 0; n < data.length(); ++n )
      {
        json::value bar_def = data[n];
        json::value color_v = bar_def.k2v(L"color"); 
        json::value value_v = bar_def.k2v(L"value");
        if( color_v.is_undefined() || value_v.is_undefined())
        {
          draw_message( gx, width, height, const_wchars(L"Bad data structure") );
          return; 
        }
        draw_bar(gx, width, height, n, data.length(), color(color_v.get(0)), value_v.get(1.0));
      }
    }

	/*!
	 * \brief Reads an ECMAScript conformant number from the input buffer
	 */
bool parser_UTF8::readnum(JSON::value &rv){
	bool flt=false;
	const char *strt =bfr.ptr;
	bool fail=false;
	while (charisNumeric(*(bfr.ptr))){
		if (*(bfr.ptr) == '.' || *(bfr.ptr) == 'e' || *(bfr.ptr) == 'E'){flt=true;}
		++bfr.ptr;
		if (bfr.ptr == bfr.end) break;
	}
	int len = bfr.ptr - strt;
	char *tmpbuf = new char[len +1];
	memcpy(tmpbuf,strt,len);
	tmpbuf[len] = '\0';
	if (flt){
		char *nd;
		double v = strtod(tmpbuf,&nd);
		if (nd != tmpbuf+len) fail=true;
		rv.setnumber(v);
	}else{
		aint v;
		char *nd;
		v=strtoaint(tmpbuf,&nd,10);
		if (nd != tmpbuf+len) fail=true;
		rv.setnumber(v);
	}
	delete [] tmpbuf;
	return !fail;
}

 json::value main_frame::open(json::value url, json::value param)
 {
   if( !url.is_string() )
     return json::value(false);
   sciter::main_frame* wnd = new sciter::main_frame(url.to_string().c_str());
   return json::value(wnd != 0);
 }

bool UTF_test::readarray(){
	JSON::parser_UTF8 parser("[ \"a\" , \"b\" ]");
	JSON::value a;
	parser.readarray(a);
	if (a.getrawarray().size() != 2){
		return false;
	}

	parser.bfr.mapstring("[ 3 1 4 1 5 9 2 6 5 3]");
	parser.getvalue(a);
	if (a.getrawarray().size() != 10){
		return false;
	}
	if (a[5].getinteger() != 9) return false;

	parser.bfr.mapstring("[ [1,1,2,3,5],[8,13,21,34]]");
	parser.getvalue(a);
	astr tmp;
	a.getstring(tmp);

	if (tmp != A(" [  [ 1 , 1 , 2 , 3 , 5 ]  ,  [ 8 , 13 , 21 , 34 ]  ] ")){
		return false;
	}

	return true;
}

void HandleJson::EndTask(json::value jsonObj)
{
    /// Get the value for Json Object.
    int jobId = jsonObj.at(U("JobId")).as_integer();
    int taskId = jsonObj.at(U("TaskId")).as_integer();

    JobTaskDb::GetInstance().EndTask(jobId, taskId);
}

StartTaskArgs StartTaskArgs::FromJson(const json::value& j)
{
    StartTaskArgs args(
        JsonHelper<int>::Read("JobId", j.at("m_Item1")),
        JsonHelper<int>::Read("TaskId", j.at("m_Item1")),
        ProcessStartInfo::FromJson(j.at("m_Item2")));

    return std::move(args);
}

bool UTF_test::read_file(){
	JSON::parser_UTF8 parser;
	JSON::value value;
	parser.parsefile(value, "test.json");

	if (parser.fail()) return false;
	return true;
	astr s = value.getchild("Hello").getrawstring();
	if (s != A("world")) return false;
	return true;
}

static string_t get_string( const json::value& obj, const string_t& key, const string_t& def ) {
	if( !obj.has_field( key ) ) {
		return def;
	}

	json::value val = obj.at( key );
	if( val.is_null( ) ) {
		return def;
	}
	return val.as_string( );
}

static void __print_scalar (string & result, const json::value & v)
{
    if (v.is_null()) {
        result.append("null");
    } else if (v.is_string()) {
		string r;
		result.append(1, '"');
		result.append(v.get<string>());
		result.append(1, '"');
	} else {
    	result.append(v.get<string>());
    }
}

bool UTF_test::reado1(){
	JSON::parser_UTF8 parser("{a:\"ba\", b:2}");
	astr s;
	JSON::value v;
	parser.parse(v);
	if (parser.errorcount() > 2) return false; // If error 11 is enabled, we don't want to fail here
	astr dst;
	v.getstring(dst,true,false);
	if (
		   (dst != A(" { \"a\" : \"ba\" , \"b\" : 2 } "))
		&& (dst != A(" { \"b\" : 2 , \"a\" : \"ba\" } "))
		){ return false;}
	return true;
}

	/*!
	 * \brief Reads an array from the input stream into \p rv
	 */
bool parser_UTF8::readarray(JSON::value &rv){
	rv.setarray();
	if (*bfr.ptr != '[') return false;
	++bfr.ptr;

	bool first=true;
	while (1){
		JSON::value curval;

		skipWS();
		if (bfr.ptr >= bfr.end){
			adderror(5);
			return false;
		}
		
		if (*bfr.ptr == ']'){
			++bfr.ptr;
			return true;
		}else if (*bfr.ptr != ','){
			if (first!=true){adderror(8);}
		}else{
			++bfr.ptr;
			skipWS();
			if (bfr.ptr >= bfr.end){
				adderror(5);
				return false;
			}
			if (*bfr.ptr == ']'){
				++bfr.ptr;
				return true;
			}
		}
		
		skipWS();
		if (bfr.ptr == bfr.end){
			adderror(5); return false;
		}
		
		
		getvalue(curval);
		if (curval.getdatatype() == datatype::_undefined && *(bfr.ptr)!=','){
			adderror(8);
			return false;
		}
		rv.addvalue(curval);
		first=false;
	}
	return true;
}

static void __print_container (string & result
        , json::value const & value
        , print_spec const & pspec
        , int indent)
{
    if (value.size() == 0) { 
        __print_open_brace(result, value, pspec);
        __print_close_brace(result, value, pspec);
        return;
    }
    
    json::value::const_iterator it_begin = value.cbegin();
    json::value::const_iterator it_end   = value.cend();
    json::value::const_iterator it       = it_begin;
    json::value::const_iterator it_next  = it_begin;
        
    ++it_next;
    
    indent += pspec.base_indent;
    
    __print_open_brace(result, value, pspec);
    result.append(pspec.new_line); // container content always begin after new line
    
    for (; it != it_end; ++it, ++it_next) {
        if (it == it_begin) {
            __print_indent(result, pspec, indent);
            
            if (pspec.comma_position == json::comma_next_line) {
                __print_indent(result, pspec, pspec.first_item_indent);
            }
        }
        
        if (value.is_object()) {
            __print_value(result, it.key(), *it, pspec, indent);
        } else {
            __print_value(result, *it, pspec, indent);
        }
        
        if (it_next != it_end) {
            __print_comma(result, pspec, indent);
        }
    }
    
    indent -= pspec.base_indent;    
    
    result.append(pspec.new_line);
    __print_indent(result, pspec, indent);
    __print_close_brace(result, value, pspec);
}

 // sets checkboxes by bit mask 
 inline void set_checkbox_bits(dom::element& el, const json::value& t )
 {
   selected_cb selected;
   dom::element r = el.parent(); // ATTN: I assume here that all checkboxes in the group belong to the same parent!
   r.find_all(&selected, "[type='checkbox'][name='%S']", el.get_attribute("name"));
   int m = 1, v = selected.elements.size()==1?(t.get(false)?1:0):t.get(0);
   for( unsigned int n = 0; n < selected.elements.size(); ++n, m <<= 1 )
   {
     dom::element& e = selected.elements[n];
     if( (v & m) != 0)
         e.set_state(  STATE_CHECKED, 0 ) ;
     else
         e.set_state(  0, STATE_CHECKED ) ;
   }
 }

void HandleJson::StartTask(json::value jsonObj, std::string callBackUri)
{
    std::cout << "StartTask ... " << std::endl;

    // Get value from Json Object.
    auto arg = jsonObj.at(U("m_Item1"));
    auto startInfoJson = jsonObj.at(U("m_Item2"));
    int jobId = arg.at(U("JobId")).as_integer();
    int taskId = arg.at(U("TaskId")).as_integer();
    ProcessStartInfo *startInfo = ProcessStartInfo::FromJson(startInfoJson);

    std::cout << "start the task: " << startInfo->commandLine << std::endl;

    JobTaskDb::GetInstance().StartJobAndTask(jobId, taskId, startInfo, callBackUri);
}

static void __print_value (string & result
        , string const & key
        , json::value const & value
        , print_spec const & pspec
        , int indent)
{
    result.append(__stringify(key));
    result.append(pspec.ws_before_kvseparator);
    result.append(pspec.key_separator);
    
    if (value.is_scalar()) {
        result.append(pspec.ws_after_kvseparator);
        __print_scalar(result, value);
    } else {
        if (pspec.brace_position == json::brace_same_line) {
            result.append(pspec.ws_after_kvseparator);
        } else if (pspec.brace_position == json::brace_next_line) {
            result.append(pspec.new_line);
            __print_indent(result, pspec, indent);
            __print_brace_indent(result, pspec, pspec.brace_indent);
        }
        
        indent += pspec.brace_indent;
        __print_container(result, value, pspec, indent);
        indent -= pspec.brace_indent;
    }
}

void print_json(const json::value & jvalue)
{
   if (!jvalue.is_null())
   {
        cout << jvalue << endl;
   }
}

void RemoteExecutor::ReportTaskCompletion(
    int jobId, int taskId, int taskRequeueCount, json::value jsonBody,
    const std::string& callbackUri)
{
    try
    {
        if (!jsonBody.is_null())
        {
            Logger::Debug(jobId, taskId, taskRequeueCount,
                "Callback to {0} with {1}", callbackUri, jsonBody);

            client::http_client client = HttpHelper::GetHttpClient(callbackUri);
            http_request request = HttpHelper::GetHttpRequest(methods::POST, jsonBody);
            http_response response = client.request(request).get();

            Logger::Info(jobId, taskId, taskRequeueCount,
                "Callback to {0} response code {1}", callbackUri, response.status_code());
        }
    }
    catch (const std::exception& ex)
    {
        this->jobTaskTable.RequestResync();
        Logger::Error(jobId, taskId, taskRequeueCount,
            "Exception when sending back task result. {0}", ex.what());
    }
}

void PacketStreamWriter::WriteMeta(PacketStreamSourceId src, const json::value& data)
{
    SCOPED_LOCK;
    writeTag(_stream, TAG_SRC_JSON);
    writeCompressedUnsignedInt(_stream, src);
    data.serialize(std::ostream_iterator<char>(_stream), false);
}

inline void __print_close_brace (string & result, json::value const & v, print_spec const & pspec)
{
    if (v.is_array()) {
        result.append(pspec.close_array_brace);
    } else {
        result.append(pspec.close_object_brace);
    }
}

void GoogleSearchClient::flattenJsonInnerLoop(json::value const & val, FlatJsonObject & json_map) {
  // input : Body of the google search response as json::value
  // This recursive function parse the Json raw value to a C++ multimap
  if (!val.is_null() && val.is_object()) {
    for (auto const &iter : val.as_object()) {
      //iter on each element for Json object type. Return a vect<string_t,json::value>
      const auto &mapKey = iter.first;
      const auto &content = iter.second;
      json_map.insert(std::pair<utility::string_t, utility::string_t>(mapKey, content.serialize()));
      flattenJsonInnerLoop(content, json_map);
    }
  } else if (val.is_array()) {
    for (auto const &content : val.as_array()) {
      //iter on each element for Json array type. Return a json::value
      flattenJsonInnerLoop(content, json_map);
    }
  }
}