package com.coralblocks.coralreactor.client.bench.google;

import java.nio.ByteBuffer;
import java.util.Iterator;

import com.coralblocks.coralbits.ds.IdentityMap;
import com.coralblocks.coralbits.ds.PooledLinkedList;
import com.coralblocks.coralbits.util.ByteBufferUtils;
import com.coralblocks.coralreactor.client.Client;
import com.coralblocks.coralreactor.nio.NioReactor;
import com.coralblocks.coralreactor.server.Server;
import com.coralblocks.coralreactor.server.http.HttpServer;
import com.coralblocks.coralreactor.util.Configuration;
import com.coralblocks.coralreactor.util.MapConfiguration;

public class AsyncHttpServer extends HttpServer implements GoogleFinanceListener {

    // number of http clients used to connect to google
    private final int numberOfHttpClients;

    // the clients used to connect to google
    private final GoogleFinanceClient[] googleClients;

    // a list of clients waiting for responses from google (for each google http connection)
    private final IdentityMap<GoogleFinanceClient, PooledLinkedList<Client>> pendingRequests;

    private final StringBuilder response = new StringBuilder(1024);
    private final StringBuilder symbol = new StringBuilder(32);
    private final StringBuilder price = new StringBuilder(32);

    public AsyncHttpServer(NioReactor nio, int port, Configuration config) {
        super(nio, port, config);
        this.numberOfHttpClients = config.getInt("numberOfHttpClients");
        this.googleClients  = new GoogleFinanceClient[numberOfHttpClients];
        this.pendingRequests = new IdentityMap<GoogleFinanceClient, PooledLinkedList<Client>>(numberOfHttpClients);

        MapConfiguration googleFinanceConfig = new MapConfiguration();
        googleFinanceConfig.add("readBufferSize", 512 * 1024); // the html page is big...

        for(int i = 0; i < googleClients.length; i++) {
            googleClients[i] = new GoogleFinanceClient(nio, "www.google.com", 80, googleFinanceConfig);
            googleClients[i].addListener(this);
            googleClients[i].open();
            pendingRequests.put(googleClients[i], new PooledLinkedList<Client>());
        }
    }

    private CharSequence parseSymbolFromRequest(ByteBuffer request) {
        // for simplicity we assume that the symbol is the request
        // Ex: GET /GOOG HTTP/1.1 => the symbol is GOOG

        int pos = ByteBufferUtils.positionOf(request, '/');

        if (pos == -1) return null;

        request.position(pos + 1);

        pos = ByteBufferUtils.positionOf(request, ' ');

        if (pos == -1) return null;

        request.limit(pos);

        symbol.setLength(0);
        ByteBufferUtils.parseString(request, symbol);

        return symbol;
    }

    @Override
    protected void handleMessage(Client client, ByteBuffer msg) {

        HttpAttachment a = (HttpAttachment) getAttachment(client);

        ByteBuffer request = a.getRequest();

        CharSequence symbol = parseSymbolFromRequest(request);

        if (symbol == null) return;

        long clientId = getClientId(client);

        // distribute requests across our Google http clients...
        int index = (int) (clientId % numberOfHttpClients);

        GoogleFinanceClient googleClient = googleClients[index];

        if (!googleClient.isConnectionOpen()) {
            client.close();
            return;
        }

        // send the request to google (it fully supports http pipelining)
        googleClient.sendPriceRequest(symbol);

        // add this client to the line of clients waiting for a response from the google http client
        pendingRequests.get(googleClient).add(client);
    }

    @Override // from GoogleFinanceListener interface
    public void onSymbolPrice(GoogleFinanceClient googleClient, CharSequence symbol, ByteBuffer priceBuffer) {

        // Got a response from google, respond to the client waiting for the price...

        PooledLinkedList<Client> clients = pendingRequests.get(googleClient);
        Client client = clients.removeFirst();

        price.setLength(0);
        ByteBufferUtils.parseString(priceBuffer, price);

        response.setLength(0);
        response.append("HTTP/1.1 200 OK\n");
        response.append("Content-Type: text/plain\n");
        response.append("Server: CoralReactor\n");
        response.append("Date: ").append(getDateTime()).append("\n");
        response.append("Content-length: ").append(price.length()).append("\n");
        response.append("\n");
        response.append(price);

        client.send(response);
    }

    @Override // from GoogleFinanceListener interface
    public void onConnectionOpened(GoogleFinanceClient client) {
        // NOOP
    }

    @Override // from GoogleFinanceListener interface
    public void onConnectionTerminated(GoogleFinanceClient googleClient) {

        // Our connection to google was broken... close all clients waiting on this connection...

        PooledLinkedList<Client> clients = pendingRequests.get(googleClient);
        Iterator<Client> iter = clients.iterator();
        while(iter.hasNext()) {
            Client c = iter.next();
            if (c.isOpen()) c.close();
        }
        clients.clear();
    }

    public static void main(String[] args) {

        int httpConnections = Integer.parseInt(args[0]);
        int port = Integer.parseInt(args[1]);

        NioReactor nio = NioReactor.create();
        MapConfiguration config = new MapConfiguration();
        config.add("numberOfHttpClients", httpConnections);
        Server server = new AsyncHttpServer(nio, port, config);
        server.open();
        nio.start();

    }
}