//-------------------------------------------------------------------------------
// TCP client start
//-------------------------------------------------------------------------------
err_t ICACHE_FLASH_ATTR tc_go(void)
{
	err_t err = ERR_USE;
	if((tc_init_flg & TC_RUNNING) || iot_data_processing == NULL) return err; // выход, если процесс запущен или нечего запускать
	#if DEBUGSOO > 4
		os_printf("Run: %x, %u\n", iot_data_processing, iot_data_processing->min_interval);
	#endif
	err = tc_init(); // инициализация TCP
	if(err == ERR_OK) {
		tc_init_flg |= TC_RUNNING; // процесс запущен
		run_error_timer(TCP_REQUEST_TIMEOUT); // обработать ошибки и продолжение

#if DEBUGSOO > 4
		int i;
		for (i = 0; i < DNS_TABLE_SIZE; ++i) {
			os_printf("TDNS%d: %d, %s, " IPSTR " (%d)\n", i, dns_table[i].state, dns_table[i].name, IP2STR(&dns_table[i].ipaddr), dns_table[i].ttl);
		}
#endif

		err = dns_gethostbyname(iot_server_name, &tc_remote_ip, (dns_found_callback)tc_dns_found_callback, NULL);
#if DEBUGSOO > 4
		os_printf("dns_gethostbyname(%s)=%d ", iot_server_name, err);
#endif
		if(err == ERR_OK) {	// Адрес разрешен из кэша или локальной таблицы
			err = tcpsrv_client_start(tc_servcfg, tc_remote_ip.addr, DEFAULT_TC_HOST_PORT);
		} else if(err == ERR_INPROGRESS) { // Запущен процесс разрешения имени с внешнего DNS
			err = ERR_OK;
		}
		if (err != ERR_OK) {
			tc_init_flg &= ~TC_RUNNING; // процесс не запущен
//				tc_close();
		}
	}
	return err;
}

// Lua: net.dns.resolve( domain, function(sk, ip) )
static int net_dns_static( lua_State* L ) {
  size_t dl;
  const char* domain = luaL_checklstring(L, 1, &dl);
  if (!domain && dl > 128) {
    return luaL_error(L, "wrong domain");
  }

  luaL_checkanyfunction(L, 2);
  lua_pushvalue(L, 2);  // copy argument (func) to the top of stack
  int cbref = luaL_ref(L, LUA_REGISTRYINDEX);
  if (cbref == LUA_NOREF) {
    return luaL_error(L, "wrong callback");
  }
  int *cbref_ptr = c_zalloc(sizeof(int));
  cbref_ptr[0] = cbref;
  ip_addr_t addr;
  err_t err = dns_gethostbyname(domain, &addr, net_dns_static_cb, cbref_ptr);
  if (err == ERR_OK) {
    net_dns_static_cb(domain, &addr, cbref_ptr);
    return 0;
  } else if (err == ERR_INPROGRESS) {
    return 0;
  } else {
    int e = lwip_lua_checkerr(L, err);
    c_free(cbref_ptr);
    return e;
  }
  return 0;
}

int GAgent_GetHostByName(char *domain, char *IPAddress)
{
    unsigned char Err;
    ip_addr_t ip_addr;
    char str[32];

    memset(str, 0x0, sizeof(str));

    switch (dns_gethostbyname(domain, &ip_addr, Gagent_ServerFound, NULL)) {
        case ERR_OK:
			memcpy((unsigned char*)IPAddress, (unsigned char*)inet_ntoa(ip_addr.addr), strlen(inet_ntoa(ip_addr.addr)) + 1);
        	GAgent_Printf(GAGENT_LOG, "ok Server name %s, first address: %s", 
                domain, inet_ntoa(domain_ipaddr.addr));
			return 0;
        case ERR_INPROGRESS:
            GAgent_Printf(GAGENT_LOG, "dns_gethostbyname called back success.\n\r");

			/* Waiting for connect success */
		    OSSemPend(pdomainSem, 1000, &Err);
		
		    if (domain_flag == 1) {
		        memcpy((unsigned char*)IPAddress, (unsigned char*)inet_ntoa(domain_ipaddr.addr), strlen(inet_ntoa(domain_ipaddr.addr)) + 1);
		        GAgent_Printf(GAGENT_LOG, "call back Server name %s, first address: %s", 
		                domain, inet_ntoa(domain_ipaddr.addr));
				return 0;
		    } else {
		        return -1;
		    }
            break;

        default:
            GAgent_Printf(GAGENT_LOG, "dns_gethostbyname called back error.\n\r");
            return -1;
    }
}

/**
 * Send out an sntp request via raw API.
 *
 * @param arg is unused (only necessary to conform to sys_timeout)
 */
static void sntp_request(void *arg) {
    ip_addr_t sntp_server_address;
    err_t err;

    LWIP_UNUSED_ARG(arg);

    /* Initialize SNTP server address */
#if SNTP_SERVER_DNS
    err = dns_gethostbyname(sntp_server_addresses[sntp_current_server], &sntp_server_address, sntp_dns_found, NULL);

    if (err == ERR_INPROGRESS) {
        /* DNS request sent, wait for sntp_dns_found being called */
        LWIP_DEBUGF(SNTP_DEBUG_STATE, ("sntp_request: Waiting for server address to be resolved.\n"));
        return;
    }
#else /* SNTP_SERVER_DNS */
    err = ipaddr_aton(sntp_server_addresses[sntp_current_server], &sntp_server_address) ? ERR_OK : ERR_ARG;
#endif /* SNTP_SERVER_DNS */

    if (err == ERR_OK) {
        sntp_send_request(&sntp_server_address);
    } else {
        /* address conversion failed, try another server */
        LWIP_DEBUGF(SNTP_DEBUG_WARN_STATE, ("sntp_request: Invalid server address, trying next server.\n"));
        sys_timeout((u32_t)SNTP_RETRY_TIMEOUT, sntp_try_next_server, NULL);
    }
}

static void
handle_req_state(void)
{
    switch (req_state) {
    case REQ_DNS_INIT:
        CYG_TEST_INFO("Trying to resolve host name");
        if (dns_gethostbyname(CYGDAT_NET_LWIP_PPP_TEST_HOST, &host_addr,
                              dns_found_cb, NULL) == ERR_OK) {
            // Cached
            req_state = REQ_DNS_SUCCESS;
            break;
        }
        req_state = REQ_DNS_WAIT;
        break;
    case REQ_DNS_WAIT:
        break;
    case REQ_DNS_FAILED:
        CYG_TEST_INFO("Failed to resolve host name");
        test_state = TEST_PPP_CLOSE;
        break;
    case REQ_DNS_SUCCESS:
        CYG_TEST_INFO("Successfully resolved host name");
        success++;
        test_state = TEST_PPP_CLOSE;
        break;
    }
}

void NtpClient::requestTime()
{
	if (!WifiStation.isConnected())
	{
		connectionTimer.initializeMs(1000, TimerDelegate(&NtpClient::requestTime, this)).startOnce();
		return;
	}

	struct ip_addr resolvedIp;
	int result = dns_gethostbyname(this->server.c_str(), &resolvedIp,
			staticDnsResponse, (void*) this);

	switch (result)
	{
	case ERR_OK:
		// Documentation says this will be the result if the string is already
		// an ip address in dotted decimal form or if the host is found in dns cache.
		// however I'm not sure if the dns cache is working since this never seems to
		// be called for a host lookup other than an ip address.
		// Doesn't really matter since the loockup will be fast anyways, the host
		// is most likely found in the dns cache of the next node the query is sent to.
		internalRequestTime(resolvedIp);
		break;
	case ERR_INPROGRESS:
		// currently finding ip, internalRequestTime() will be called when its found.
		//debugf("DNS IP lookup in progress.");
		break;
	default:
		debugf("DNS lookup error occurred.");
		break;
	}
}

/******************************************************************************
 * FunctionName : on_timer
 * Description  : 1s time callback to check dns found
 * Parameters   : arg -- Additional argument to pass to the callback function
 * Returns      : none
*******************************************************************************/
static void ICACHE_FLASH_ATTR
on_timer(void *arg)
{
    int err = -1;
    struct user_dns_param *param = (struct user_dns_param *)arg;

    switch(param->ip.addr)
    {
        case 0xFFFFFFFF:
        case 0x00000000:
            if(0 < param->retry--)
            {
                DEBUG_WARNING("retry\n");
                err = dns_gethostbyname(param->hostname, &param->ip, on_found, param);
                os_timer_arm(&param->tmr, 1000, 0);
                return;
            }
            else
            {
                err = ETIMEDOUT;
            }
            break;
        default:
            DEBUG_INFO("callback\n");
            err = 0;
            break;
    }

    param->h(err, &param->ip, param);
}

bool TcpConnection::connect(String server, int port)
{
	if (tcp == NULL)
		initialize(tcp_new());

	ip_addr_t addr;

	debugf("connect to: %s", server.c_str());
	canSend = false; // Wait for connection
	DnsLookup *look = new DnsLookup { this, port };
	err_t dnslook = dns_gethostbyname(server.c_str(), &addr, staticDnsResponse, look);
	if (dnslook != ERR_OK)
	{
		if (dnslook == ERR_INPROGRESS)
			return true;
		else
		{
			delete look;
			return false;
		}
	}
	delete look;

	return internalTcpConnect(addr, port);
}

/**
 * Resolve the given hostname to an IP address.
 * @param aHostname     Name to be resolved
 * @param aResult       IPAddress structure to store the returned IP address
 * @return 1 if aIPAddrString was successfully converted to an IP address,
 *          else error code
 */
int ESP8266WiFiGenericClass::hostByName(const char* aHostname, IPAddress& aResult) {
    ip_addr_t addr;
    aResult = static_cast<uint32_t>(0);

    if(aResult.fromString(aHostname)) {
        // Host name is a IP address use it!
        DEBUG_WIFI_GENERIC("[hostByName] Host: %s is a IP!\n", aHostname);
        return 1;
    }

    DEBUG_WIFI_GENERIC("[hostByName] request IP for: %s\n", aHostname);
    err_t err = dns_gethostbyname(aHostname, &addr, &wifi_dns_found_callback, &aResult);
    if(err == ERR_OK) {
        aResult = addr.addr;
    } else if(err == ERR_INPROGRESS) {
        esp_yield();
        // will return here when dns_found_callback fires
        if(aResult != 0) {
            err = ERR_OK;
        }
    }

    if(err != 0) {
        DEBUG_WIFI_GENERIC("[hostByName] Host: %s lookup error: %d!\n", aHostname, err);
    } else {
        DEBUG_WIFI_GENERIC("[hostByName] Host: %s IP: %s\n", aHostname, aResult.toString().c_str());
    }

    return (err == ERR_OK) ? 1 : 0;
}

//Execute request & return OK if found, NOTFOUND or ERROR on error, or PROCESSING if the request has not completed yet
void LwipNetDnsRequest::poll()
{
  err_t  err;
  switch(m_state)
  {
  case LWIPNETDNS_START: //First req, let's call dns_gethostbyname
    ip_addr_t ipStruct;
    err = dns_gethostbyname(m_hostname, &ipStruct, LwipNetDnsRequest::sFoundCb, (void*) this );
    if( err == ERR_OK )
    {
      m_ip = IpAddr(&ipStruct);
      m_state = LWIPNETDNS_OK;
      DBG("DNS: Ip found in cache.\n");
    }
    else if( err == ERR_INPROGRESS)
    {
      DBG("DNS: Processing.\n");
      m_state = LWIPNETDNS_PROCESSING;
    }
    else //Likely ERR_VAL
    {
      DBG("DNS: Error on init.\n");
      m_state = LWIPNETDNS_ERROR;
    }
    break;
  case LWIPNETDNS_PROCESSING:
    break; //Nothing to do, DNS is polled on interrupt
  case LWIPNETDNS_OK:
    if(!m_cbFired)
    {
      DBG("DNS: Ip found.\n");
      m_cbFired = true;
      onReply(NETDNS_FOUND); //Raise callback
    }
    break;
  case LWIPNETDNS_NOTFOUND:
    if(!m_cbFired)
    {
      DBG("DNS: could not be resolved.\n");
      m_cbFired = true;
      onReply(NETDNS_NOTFOUND); //Raise callback
    }
    break;
  case LWIPNETDNS_ERROR:
  default:
    if(!m_cbFired)
    {
      DBG("DNS: Error.\n");
      m_cbFired = true;
      onReply(NETDNS_ERROR); //Raise callback
    }
    break;
  }
  if(m_closing && (m_state!=LWIPNETDNS_PROCESSING)) //Check wether the closure has been reqd
  {
    DBG("LwipNetDnsRequest: Closing in poll()\n");
    NetDnsRequest::close();
  }
}

void
dns_suite(void)
{
    evdns_init();
    dns_gethostbyname();
    dns_gethostbyaddr();

    evdns_shutdown(0);
}

/**
 * SNTP thread
 */
static void sntp_thread(void *arg) {
	LWIP_UNUSED_ARG(arg);
	while (1) {
		dns_gethostbyname(SNTP_SERVER_NAME, &SNTPaddr, sntp_server_found, NULL);
		vTaskSuspend(NULL);
		sntp_request();
		sys_msleep(SNTP_UPDATE_DELAY);
	}
}

static int tls_socket_connect( lua_State *L ) {
  tls_socket_ud *ud = (tls_socket_ud *)luaL_checkudata(L, 1, "tls.socket");
  luaL_argcheck(L, ud, 1, "TLS socket expected");
  if(ud==NULL){
  	NODE_DBG("userdata is nil.\n");
  	return 0;
  }

  if (ud->pesp_conn) {
    return luaL_error(L, "already connected");
  }

  u16 port = luaL_checkinteger( L, 2 );
  size_t il;
  const char *domain = "127.0.0.1";
  if( lua_isstring(L, 3) )
    domain = luaL_checklstring( L, 3, &il );
  if (port == 0)
    return luaL_error(L, "invalid port");
  if (domain == NULL)
    return luaL_error(L, "invalid domain");

  ud->pesp_conn = (struct espconn*)c_zalloc(sizeof(struct espconn));
  if(!ud->pesp_conn)
    return luaL_error(L, "not enough memory");
  ud->pesp_conn->proto.udp = NULL;
  ud->pesp_conn->proto.tcp = (esp_tcp *)c_zalloc(sizeof(esp_tcp));
  if(!ud->pesp_conn->proto.tcp){
    c_free(ud->pesp_conn);
    ud->pesp_conn = NULL;
    return luaL_error(L, "not enough memory");
  }
  ud->pesp_conn->type = ESPCONN_TCP;
  ud->pesp_conn->state = ESPCONN_NONE;
  ud->pesp_conn->reverse = ud;
  ud->pesp_conn->proto.tcp->remote_port = port;
  espconn_regist_connectcb(ud->pesp_conn, (espconn_connect_callback)tls_socket_onconnect);
  espconn_regist_disconcb(ud->pesp_conn, (espconn_connect_callback)tls_socket_ondisconnect);
  espconn_regist_reconcb(ud->pesp_conn, (espconn_reconnect_callback)tls_socket_onreconnect);
  espconn_regist_recvcb(ud->pesp_conn, (espconn_recv_callback)tls_socket_onrecv);
  espconn_regist_sentcb(ud->pesp_conn, (espconn_sent_callback)tls_socket_onsent);

  if (ud->self_ref == LUA_NOREF) {
    lua_pushvalue(L, 1);  // copy to the top of stack
    ud->self_ref = luaL_ref(L, LUA_REGISTRYINDEX);
  }

  ip_addr_t addr;
  err_t err = dns_gethostbyname(domain, &addr, (dns_found_callback)tls_socket_dns_cb, ud);
  if (err == ERR_OK) {
    tls_socket_dns_cb(domain, &addr, ud);
  } else if (err != ERR_INPROGRESS) {
    tls_socket_dns_cb(domain, NULL, ud);
  }

  return 0;
}

void set_clock_sntp(const char * ntp_server, int i)
{
	strcpy(dns_hostname, ntp_server);

	//To get the ball rolling, all we have to do is send a request to get the NTP server's IP address.
	dns_gethostbyname(dns_hostname, &ntp_server_ip, send_ntp_req, NULL);

	//...oh, and save the system GMT offset for later.
	gmt_offset = i;
}

void dns_dorequest(void *arg)
{
  char* dnsname = "3com.com";
  ip_addr_t dnsresp;
  LWIP_UNUSED_ARG(arg);
 
  if (dns_gethostbyname(dnsname, &dnsresp, dns_found, 0) == ERR_OK) {
    dns_found(dnsname, &dnsresp, 0);
  }
}

void ninit(void)
{
	sntp_init();
	ip_addr_t ip;
	int r = dns_gethostbyname("pool.ntp.org", &ip, ntp_dns_found, NULL);
    if (r == ESPCONN_OK)
    {
    	sntp_setserver(0, &ip);
    }

}

/*******************************************************************************
** Name: WebDNS
** Input:void
** Return: void
** Owner:zhuzhe
** Date: 2014.6.25
** Time: 15:33:52
*******************************************************************************/
_WEB_TASK_WEBTASK_READ_
COMMON API void WebDNS(void)
{
#if LWIP_DNS
    {
        char hostname[] = "www.baidu.com";
        ip_addr_t addr;

        dns_gethostbyname(hostname, &addr, dns_found, NULL);
    }
#endif
}

/**
 * Execute a DNS query
 * Called from netconn_gethostbyname
 *
 * @param arg the dns_api_msg pointing to the query
 */
void
do_gethostbyname(void *arg)
{
    struct dns_api_msg *msg = (struct dns_api_msg*)arg;

    *msg->err = dns_gethostbyname(msg->name, msg->addr, do_dns_found, msg);
    if (*msg->err != ERR_INPROGRESS) {
        /* on error or immediate success, wake up the application
         * task waiting in netconn_gethostbyname */
        sys_sem_signal(msg->sem);
    }
}

/**
 * Execute a DNS query
 * Called from netconn_gethostbyname
 *
 * @param arg the dns_api_msg pointing to the query
 */
void
lwip_netconn_do_gethostbyname(void *arg)
{
  struct dns_api_msg *msg = (struct dns_api_msg*)arg;

  API_EXPR_DEREF(msg->err) = dns_gethostbyname(msg->name, API_EXPR_REF(msg->addr), lwip_netconn_do_dns_found, msg);
  if (API_EXPR_DEREF(msg->err) != ERR_INPROGRESS) {
    /* on error or immediate success, wake up the application
     * task waiting in netconn_gethostbyname */
    sys_sem_signal(API_EXPR_REF(msg->sem));
  }
}

bool AsyncClient::connect(const char* host, uint16_t port){
    ip_addr_t addr;
    err_t err = dns_gethostbyname(host, &addr, (dns_found_callback)&_s_dns_found, this);
    if(err == ERR_OK) {
        return connect(IPAddress(addr.u_addr.ip4.addr), port);
    } else if(err == ERR_INPROGRESS) {
        _connect_port = port;
        return true;
    }
    log_e("error: %d", err);
    return false;
}