/*
* Copyright 2017-present Open Networking Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

package org.onosproject.incubator.protobuf.services.nb;

import io.grpc.BindableService;
import io.grpc.ManagedChannel;
import io.grpc.inprocess.InProcessChannelBuilder;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.onosproject.core.ApplicationId;
import org.onosproject.core.DefaultApplicationId;
import org.onosproject.grpc.core.models.ApplicationIdProtoOuterClass;
import org.onosproject.grpc.nb.net.meter.MeterServiceGrpc;
import org.onosproject.grpc.nb.net.meter.MeterServiceNbProto;
import org.onosproject.grpc.net.meter.models.BandProtoOuterClass;
import org.onosproject.grpc.net.meter.models.MeterEnumsProto;
import org.onosproject.grpc.net.meter.models.MeterProtoOuterClass;
import org.onosproject.grpc.net.meter.models.MeterRequestProtoOuterClass;
import org.onosproject.net.DeviceId;
import org.onosproject.net.meter.Band;
import org.onosproject.net.meter.DefaultBand;
import org.onosproject.net.meter.Meter;
import org.onosproject.net.meter.MeterCellId;
import org.onosproject.net.meter.MeterId;
import org.onosproject.net.meter.MeterListener;
import org.onosproject.net.meter.MeterRequest;
import org.onosproject.net.meter.MeterService;
import org.onosproject.net.meter.MeterState;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import static org.junit.Assert.assertTrue;


public class GrpcNbMeterServiceTest {

    private static InProcessServer<BindableService> inProcessServer;
    private static ManagedChannel channel;
    private static MeterServiceGrpc.MeterServiceBlockingStub blockingStub;

    private static final MeterService MOCK_METER = new MockMeterService();

    private static final DeviceId DEVICE_ID_1 = DeviceId.deviceId("d1");
    private static final DeviceId DEVICE_ID_2 = DeviceId.deviceId("d2");
    private static final DeviceId DEVICE_ID_3 = DeviceId.deviceId("d3");

    private static final long METER_ID_1 = 1L;
    private static final long METER_ID_2 = 2L;
    private static final long METER_ID_3 = 3L;
    private static final long METER_ID_4 = 4L;

    private static final Meter METER_1 = new MockMeter(DEVICE_ID_1, 1, METER_ID_1, 1);
    private static final Meter METER_2 = new MockMeter(DEVICE_ID_2, 1, METER_ID_2, 2);
    private static final Meter METER_3 = new MockMeter(DEVICE_ID_3, 1, METER_ID_3, 3);
    private static final Meter METER_4 = new MockMeter(DEVICE_ID_3, 1, METER_ID_4, 4);

    private static Set<Meter> allMeters = new HashSet<>();

    /**
     * Create inProcessServer and bind grpcNbMeterService.
     *
     * @throws IllegalAccessException
     * @throws IOException
     * @throws InstantiationException
     */
    @BeforeClass
    public static void setup() throws IllegalAccessException, IOException, InstantiationException {

        GrpcNbMeterService grpcNbMeterService = new GrpcNbMeterService();
        grpcNbMeterService.meterService = MOCK_METER;
        inProcessServer = new InProcessServer(GrpcNbMeterService.class);
        inProcessServer.addServiceToBind(grpcNbMeterService);

        inProcessServer.start();
        channel = InProcessChannelBuilder.forName("test").directExecutor()
                // Channels are secure by default (via SSL/TLS). For the example we disable TLS to avoid
                // needing certificates.
                .usePlaintext(true).build();
        blockingStub = MeterServiceGrpc.newBlockingStub(channel);

        allMeters.add(METER_2);
        allMeters.add(METER_3);
        allMeters.add(METER_4);
    }

    @AfterClass
    public static void down() {
        channel.shutdown();

        inProcessServer.stop();
    }

    @Test
    public void testSubmit() {
        MeterServiceNbProto.submitRequest request = MeterServiceNbProto.submitRequest.newBuilder()
                .setMeter(MeterRequestProtoOuterClass.MeterRequestProto.newBuilder()
                        .setDeviceId(DEVICE_ID_1.toString())
                        .setApplicationId(ApplicationIdProtoOuterClass.ApplicationIdProto.newBuilder()
                                .setId(METER_1.appId().id())
                                .build())
                        .setUnit(MeterEnumsProto.MeterUnitProto.KB_PER_SEC)
                        .setIsBurst(false)
                        .addBands(BandProtoOuterClass.BandProto.getDefaultInstance())
                        .setType(MeterEnumsProto.MeterRequestTypeProto.ADD)
                        .build())
                .build();
        MeterServiceNbProto.submitReply reply;

        int size = allMeters.size();
        reply = blockingStub.submit(request);
        MeterProtoOuterClass.MeterProto meter = reply.getSubmitMeter();
        assertTrue(allMeters.size() == (size + 1)
                && meter.getDeviceId().equals(METER_1.deviceId().toString())
                && meter.getApplicationId().getId() == METER_1.appId().id());

    }

    @Test
    public void testWithdraw() {
        MeterServiceNbProto.withdrawRequest request = MeterServiceNbProto.withdrawRequest.newBuilder()
                .setMeter(MeterRequestProtoOuterClass.MeterRequestProto.newBuilder()
                        .setDeviceId(DEVICE_ID_2.toString())
                        .setApplicationId(ApplicationIdProtoOuterClass.ApplicationIdProto.newBuilder()
                                .setId(1)
                                .build())
                        .setUnit(MeterEnumsProto.MeterUnitProto.KB_PER_SEC)
                        .setIsBurst(false)
                        .addBands(BandProtoOuterClass.BandProto.getDefaultInstance())
                        .setType(MeterEnumsProto.MeterRequestTypeProto.REMOVE)
                        .build())
                .setMeterId(METER_ID_2)
                .build();
        MeterServiceNbProto.withdrawReply reply;

        int size = allMeters.size();
        reply = blockingStub.withdraw(request);
        assertTrue(allMeters.size() == (size - 1));
    }

    @Test
    public void testGetMeter() {
        MeterServiceNbProto.getMeterRequest request = MeterServiceNbProto.getMeterRequest.newBuilder()
                .setDeviceId(DEVICE_ID_3.toString())
                .setMeterId(METER_ID_3)
                .build();
        MeterServiceNbProto.getMeterReply reply;

        reply = blockingStub.getMeter(request);
        MeterProtoOuterClass.MeterProto meter = reply.getMeter();
        assertTrue(meter.getApplicationId().getId() == METER_3.appId().id()
                && meter.getDeviceId().equals(DEVICE_ID_3.toString()));
    }

    @Test
    public void testGetAllMeters() {
        MeterServiceNbProto.getAllMetersRequest request = MeterServiceNbProto.getAllMetersRequest.getDefaultInstance();
        MeterServiceNbProto.getAllMetersReply reply;

        reply = blockingStub.getAllMeters(request);
        assertTrue(reply.getMetersCount() == allMeters.size());

    }

    @Test
    public void testGetMeters() {
        MeterServiceNbProto.getMetersRequest request = MeterServiceNbProto.getMetersRequest.newBuilder()
                .setDeviceId(DEVICE_ID_3.toString())
                .build();
        MeterServiceNbProto.getMetersReply reply;

        reply = blockingStub.getMeters(request);
        assertTrue(reply.getMetersCount() == 2);
    }


    /**
     * A mock class of meter.
     */
    private static class MockMeter implements Meter {

        final DeviceId deviceId;
        final ApplicationId appId;
        final MeterId meterId;
        final long baseValue;
        final List<Band> bandList;

        public MockMeter(DeviceId deviceId, int appId, long meterId, int id) {
            this.deviceId = deviceId;
            this.appId = new DefaultApplicationId(appId, String.valueOf(appId));
            this.baseValue = id * 200L;
            this.meterId = MeterId.meterId(meterId);

            Band band = DefaultBand.builder()
                    .ofType(Band.Type.REMARK)
                    .withRate(10)
                    .dropPrecedence((short) 20)
                    .burstSize(30).build();

            this.bandList = new ArrayList<>();
            this.bandList.add(band);
        }

        @Override
        public DeviceId deviceId() {
            return this.deviceId;
        }

        @Override
        public MeterId id() {
            return this.meterId;
        }

        @Override
        public MeterCellId meterCellId() {
            return this.id();
        }

        @Override
        public ApplicationId appId() {
            return this.appId;
        }

        @Override
        public Unit unit() {
            return Unit.KB_PER_SEC;
        }

        @Override
        public boolean isBurst() {
            return false;
        }

        @Override
        public Collection<Band> bands() {
            return this.bandList;
        }

        @Override
        public MeterState state() {
            return MeterState.ADDED;
        }

        @Override
        public long life() {
            return baseValue + 11;
        }

        @Override
        public long referenceCount() {
            return baseValue + 22;
        }

        @Override
        public long packetsSeen() {
            return baseValue + 33;
        }

        @Override
        public long bytesSeen() {
            return baseValue + 44;
        }
    }

    /**
     * A mock class of MeterService.
     */
    public static class MockMeterService implements MeterService {
        @Override
        public void addListener(MeterListener listener) {
        }

        @Override
        public void removeListener(MeterListener listener) {
        }

        @Override
        public Meter submit(MeterRequest meter) {
            Meter m = new MockMeter(meter.deviceId(), meter.appId().id(), METER_ID_1, 1);
            allMeters.add(m);
            return m;
        }

        @Override
        public void withdraw(MeterRequest meter, MeterId meterId) {
            Meter toRemove = null;
            for (Meter m: allMeters) {
                if (meter.appId().id() == m.appId().id() && meter.deviceId().equals(m.deviceId())
                        && m.id().equals(meterId)) {
                    toRemove = m;
                    break;
                }
            }
            if (null != toRemove) {
                allMeters.remove(toRemove);
            }
        }

        @Override
        public Meter getMeter(DeviceId deviceId, MeterId id) {
            for (Meter m: allMeters) {
                if (deviceId.equals(m.deviceId()) && m.id().equals(id)) {
                    return m;
                }
            }
            return null;
        }

        @Override
        public Collection<Meter> getAllMeters() {
            return allMeters;
        }

        @Override
        public Collection<Meter> getMeters(DeviceId deviceId) {
            List<Meter> meters = new ArrayList<>();
            for (Meter m: allMeters) {
                if (deviceId.equals(m.deviceId())) {
                    meters.add(m);
                }
            }
            return meters;
        }

        @Override
        public MeterId allocateMeterId(DeviceId deviceId) {
            return null;
        }

        @Override
        public void freeMeterId(DeviceId deviceId, MeterId meterId) {

        }
    }

}