/* Copyright 2018 Paul Stoffregen
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this
 * software and associated documentation files (the "Software"), to deal in the Software
 * without restriction, including without limitation the rights to use, copy, modify,
 * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include <Arduino.h>
#include "NativeEthernet.h"
#include "NativeDns.h"
#include "utility/NativeW5100.h"

int EthernetClient::connect(const char * host, uint16_t port)
{
    static bool first_call = true;
    if(first_call){
        sockindex = Ethernet.socket_num;
        first_call = false;
    }
    
	DNSClient dns; // Look up the host first
	IPAddress remote_addr;

	if (sockindex < Ethernet.socket_num) {
		if (Ethernet.socketStatus(sockindex) != SnSR::CLOSED) {
			Ethernet.socketDisconnect(sockindex); // TODO: should we call stop()?
		}
		sockindex = Ethernet.socket_num;
	}
	dns.begin(Ethernet.dnsServerIP());
	if (!dns.getHostByName(host, remote_addr)) return 0; // TODO: use _timeout
	return connect(remote_addr, port);
}

int EthernetClient::connect(IPAddress ip, uint16_t port)
{
    static bool first_call = true;
    if(first_call){
        sockindex = Ethernet.socket_num;
        first_call = false;
    }
	if (sockindex < Ethernet.socket_num) {
		if (Ethernet.socketStatus(sockindex) != SnSR::CLOSED) {
			Ethernet.socketDisconnect(sockindex); // TODO: should we call stop()?
		}
		sockindex = Ethernet.socket_num;
	}
#if defined(ESP8266) || defined(ESP32)
	if (ip == IPAddress((uint32_t)0) || ip == IPAddress(0xFFFFFFFFul)) return 0;
#else
	if (ip == IPAddress(0ul) || ip == IPAddress(0xFFFFFFFFul)) return 0;
#endif
	sockindex = Ethernet.socketBegin(SnMR::TCP, 8888);
	if (sockindex >= Ethernet.socket_num) return 0;
	Ethernet.socketConnect(sockindex, rawIPAddress(ip), port);
    _port = port;
	uint32_t start = millis();
	while (1) {
		uint8_t stat = Ethernet.socketStatus(sockindex);
//        Serial.print("Connect: ");
//        Serial.println(stat, HEX);
//        Serial.print("Sock Index: ");
//        Serial.println(sockindex);
        if (stat == SnSR::ESTABLISHED || stat == SnSR::CLOSE_WAIT) {
            _remoteIP = ip;
            _remotePort = port;
            return 1;
        }
        if (stat == SnSR::CLOSED) {
            Ethernet.socketClose(sockindex);
            return 0;
        }
		if (millis() - start > _timeout) break;
		delay(1);
	}
	Ethernet.socketClose(sockindex);
	sockindex = Ethernet.socket_num;
	return 0;
}

int EthernetClient::availableForWrite(void)
{
	if (sockindex >= Ethernet.socket_num) return 0;
	return Ethernet.socketSendAvailable(sockindex);
}

size_t EthernetClient::write(uint8_t b)
{
	return write(&b, 1);
}

size_t EthernetClient::write(const uint8_t *buf, size_t size)
{
    size_t ret = Ethernet.socketSend(sockindex, buf, size);
	if (sockindex >= Ethernet.socket_num) return 0;
	if (ret) return ret;
	setWriteError();
	return 0;
}

int EthernetClient::available()
{
	if (sockindex >= Ethernet.socket_num) return 0;
	struct fnet_sockaddr _from;
    fnet_size_t fromlen = sizeof(_from);
    
    int ret = 0;
    if(_remaining == 0) {
        ret = fnet_socket_recvfrom(Ethernet.socket_ptr[sockindex], Ethernet.socket_buf_receive[sockindex], Ethernet.socket_size, 0, &_from, &fromlen);
        Ethernet.socket_buf_index[sockindex] = 0;
    }
    int8_t error_handler = fnet_error_get();
    if(error_handler == -20){
        return 0;
    }
    if(ret == -1){
//        Serial.print("RecvAvailableErr: ");
//        Serial.send_now();
//        Serial.println(error_handler);
//        Serial.send_now();
        _remaining = 0;
        return 0;
    }
    
    if(ret){
        _remoteIP = _from.sa_data;
        _remotePort = FNET_HTONS(_from.sa_port);
        _remaining = ret;
//        Serial.print("Available: ");
//        Serial.println(ret);
//        Serial.send_now();
    }
    
    return _remaining;
	// TODO: do the Wiznet chips automatically retransmit TCP ACK
	// packets if they are lost by the network?  Someday this should
	// be checked by a man-in-the-middle test which discards certain
	// packets.  If ACKs aren't resent, we would need to check for
	// returning 0 here and after a timeout do another Sock_RECV
	// command to cause the Wiznet chip to resend the ACK packet.
}

int EthernetClient::read(uint8_t *buf, size_t size)
{
    if(_remaining > 0) if (size > (size_t)_remaining) size = _remaining;
	if (sockindex >= Ethernet.socket_num) return 0;
    int16_t ret = Ethernet.socketRecv(sockindex, buf, size);
    if (ret > 0) _remaining -= ret;
    return ret;
}

int EthernetClient::peek()
{
	if (sockindex >= Ethernet.socket_num) return -1;
	if (!available()) return -1;
	return Ethernet.socketPeek(sockindex);
}

int EthernetClient::read()
{
	uint8_t b;
    int16_t ret = Ethernet.socketRecv(sockindex, &b, 1);
    if (ret > 0) {
        _remaining -= ret;
        return b;
    }
	return -1;
}

void EthernetClient::flush()
{
	while (sockindex < Ethernet.socket_num) {
		uint8_t stat = Ethernet.socketStatus(sockindex);
		if (stat != SnSR::ESTABLISHED && stat != SnSR::CLOSE_WAIT) return;
		if (Ethernet.socketSendAvailable(sockindex) >= Ethernet.socket_size) return;
	}
}

void EthernetClient::stop()
{
	if (sockindex >= Ethernet.socket_num) return;

	// attempt to close the connection gracefully (send a FIN to other side)
	Ethernet.socketDisconnect(sockindex);
	unsigned long start = millis();

	// wait up to a second for the connection to close
	do {
		if (Ethernet.socketStatus(sockindex) == SnSR::CLOSED) {
			sockindex = Ethernet.socket_num;
			return; // exit the loop
		}
		delay(1);
	} while (millis() - start < _timeout);

	// if it hasn't closed, close it forcefully
	Ethernet.socketClose(sockindex);
	sockindex = Ethernet.socket_num;
}

uint8_t EthernetClient::connected()
{
	if (sockindex >= Ethernet.socket_num) return 0;

	uint8_t s = Ethernet.socketStatus(sockindex);
	return !(s == SnSR::LISTEN || s == SnSR::CLOSED || s == SnSR::FIN_WAIT ||
		(s == SnSR::CLOSE_WAIT && !available()));
}

uint8_t EthernetClient::status()
{
	if (sockindex >= Ethernet.socket_num) return SnSR::CLOSED;
	return Ethernet.socketStatus(sockindex);
}

// the next function allows us to use the client returned by
// EthernetServer::available() as the condition in an if-statement.
bool EthernetClient::operator==(const EthernetClient& rhs)
{
	if (sockindex != rhs.sockindex) return false;
	if (sockindex >= Ethernet.socket_num) return false;
	if (rhs.sockindex >= Ethernet.socket_num) return false;
	return true;
}
