import com.google.protobuf.ByteString;
import com.google.protobuf.Message;
import meerkat.bulletinboard.BulletinBoardClient;
import meerkat.bulletinboard.BulletinBoardClient.ClientCallback;
import meerkat.bulletinboard.ThreadedBulletinBoardClient;
import meerkat.protobuf.BulletinBoardAPI.*;
import meerkat.protobuf.Crypto;

import meerkat.protobuf.Voting.*;
import meerkat.util.BulletinBoardMessageComparator;

import org.junit.Before;
import org.junit.Test;

import static java.lang.Thread.sleep;
import static org.junit.Assert.*;
import static org.hamcrest.CoreMatchers.*;
import static org.hamcrest.number.OrderingComparison.*;

import java.util.Comparator;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

/**
 * Created by Arbel Deutsch Peled on 05-Dec-15.
 */
public class BulletinBoardClientIntegrationTest {

    private class PostCallback implements ClientCallback<Object>{

        @Override
        public void handleCallback(Object msg) {
            System.err.println("Post operation completed");
        }

        @Override
        public void handleFailure(Throwable t) {
            System.err.println(t.getCause() + "\n" + t.getMessage());
            assert false;
        }
    }

    private class RedundancyCallback implements ClientCallback<Float>{

        private float minRedundancy;

        public RedundancyCallback(float minRedundancy) {
            this.minRedundancy = minRedundancy;
        }

        @Override
        public void handleCallback(Float redundancy) {
            assertThat(redundancy, greaterThanOrEqualTo(minRedundancy));
        }

        @Override
        public void handleFailure(Throwable t) {
            System.err.println(t.getCause() + "\n" + t.getMessage());
            assert false;
        }
    }

    private class ReadCallback implements ClientCallback<List<BulletinBoardMessage>>{

        private List<BulletinBoardMessage> expectedMsgList;

        public ReadCallback(List<BulletinBoardMessage> expectedMsgList) {
            this.expectedMsgList = expectedMsgList;
        }

        @Override
        public void handleCallback(List<BulletinBoardMessage> messages) {
            BulletinBoardMessageComparator msgComparator = new BulletinBoardMessageComparator();

            assertThat(messages.size(), is(expectedMsgList.size()));

            Iterator<BulletinBoardMessage> expectedMessageIterator = expectedMsgList.iterator();
            Iterator<BulletinBoardMessage> receivedMessageIterator = messages.iterator();

            while (expectedMessageIterator.hasNext()) {
                assertThat(msgComparator.compare(expectedMessageIterator.next(), receivedMessageIterator.next()), is(0));
            }

        }

        @Override
        public void handleFailure(Throwable t) {
            System.err.println(t.getCause() + "\n" + t.getMessage());
            assert false;
        }
    }

    private BulletinBoardClient bulletinBoardClient;

    private PostCallback postCallback;
    private RedundancyCallback redundancyCallback;
    private ReadCallback readCallback;

    private static String PROP_GETTY_URL = "gretty.httpBaseURI";
    private static String DEFAULT_BASE_URL = "http://localhost:8081";
    private static String BASE_URL =  System.getProperty(PROP_GETTY_URL, DEFAULT_BASE_URL);

    @Before
    public void init(){

        bulletinBoardClient = new ThreadedBulletinBoardClient();

        List<String> testDB = new LinkedList<String>();
        testDB.add(BASE_URL);

        bulletinBoardClient.init(BulletinBoardClientParams.newBuilder()
            .addBulletinBoardAddress("http://localhost:8081")
            .setMinRedundancy((float) 1.0)
            .build());

        postCallback = new PostCallback();
        redundancyCallback = new RedundancyCallback((float) 1.0);

    }

    @Test
    public void postTest() {

        byte[] b1 = {(byte) 1, (byte) 2, (byte) 3, (byte) 4};
        byte[] b2 = {(byte) 11, (byte) 12, (byte) 13, (byte) 14};
        byte[] b3 = {(byte) 21, (byte) 22, (byte) 23, (byte) 24};
        byte[] b4 = {(byte) 4, (byte) 5, (byte) 100, (byte) -50, (byte) 0};

        BulletinBoardMessage msg;

        MessageFilterList filterList;
        List<BulletinBoardMessage> msgList;

        MessageID messageID;

        Comparator<BulletinBoardMessage> msgComparator = new BulletinBoardMessageComparator();

        msg = BulletinBoardMessage.newBuilder()
                .setMsg(UnsignedBulletinBoardMessage.newBuilder()
                        .addTag("Signature")
                        .addTag("Trustee")
                        .setData(ByteString.copyFrom(b1))
                        .build())
                .addSig(Crypto.Signature.newBuilder()
                        .setType(Crypto.SignatureType.DSA)
                        .setData(ByteString.copyFrom(b2))
                        .setSignerId(ByteString.copyFrom(b3))
                        .build())
                .addSig(Crypto.Signature.newBuilder()
                        .setType(Crypto.SignatureType.ECDSA)
                        .setData(ByteString.copyFrom(b3))
                        .setSignerId(ByteString.copyFrom(b2))
                        .build())
                .build();

        messageID = bulletinBoardClient.postMessage(msg,postCallback);

        try {
            sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        bulletinBoardClient.getRedundancy(messageID,redundancyCallback);

        filterList = MessageFilterList.newBuilder()
                .addFilter(
                        MessageFilter.newBuilder()
                                .setType(FilterType.TAG)
                                .setTag("Signature")
                                .build()
                )
                .addFilter(
                        MessageFilter.newBuilder()
                                .setType(FilterType.TAG)
                                .setTag("Trustee")
                                .build()
                )
                .build();

        msgList = new LinkedList<BulletinBoardMessage>();
        msgList.add(msg);

        readCallback = new ReadCallback(msgList);

        bulletinBoardClient.readMessages(filterList, readCallback);

        bulletinBoardClient.close();

    }

}