/*
 * Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
 * and is available at http://www.eclipse.org/legal/epl-v10.html
 */

package org.opendaylight.bgpmanager.thrift.client;

import java.util.*;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.protocol.TProtocol;
import org.apache.thrift.TException;
import org.apache.thrift.transport.TSocket;
import org.apache.thrift.transport.TTransport;
import org.apache.thrift.transport.TTransportException;
import org.opendaylight.bgpmanager.thrift.gen.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class BgpRouter {
    private static TTransport transport;
    private static TProtocol protocol;
    private static BgpConfigurator.Client bgpClient=null;
    private static final Logger LOGGER = LoggerFactory.getLogger(BgpRouter.class);

    private enum Optype {
        START, STOP, NBR, VRF, PFX, SRC, MHOP, LOG, AF, GR
    };

    private final static int GET_RTS_INIT = 0;
    private final static int GET_RTS_NEXT = 1;
    private final static int CONNECTION_TIMEOUT = 2000;


    private class BgpOp {
        public Optype type;
        public boolean add;
        public String[] strs;
        public int[] ints;
        public List<String> irts;
        public List<String> erts;
        public static final int ignore = 0;
        public BgpOp() {
            strs = new String[3];
            ints = new int[2];
        }
    }

    private static BgpOp bop;

    public synchronized void disconnect() {
        bgpClient = null;
        if (transport != null) {
            transport.close();
        }
    }

    public synchronized boolean connect(String bgpHost, int bgpPort) {
        String msgPiece = "BGP config server at "+bgpHost+":"+bgpPort;

        disconnect();
        try {
            TSocket ts = new TSocket(bgpHost, bgpPort, CONNECTION_TIMEOUT);
            transport = ts; 
            transport.open();
            ts.setTimeout(0);
        } catch (TTransportException tte) {
            LOGGER.error("Failed connecting to "+msgPiece+
                         "; Exception: "+tte);
            return false;
        }
        protocol = new TBinaryProtocol(transport);
        bgpClient = new BgpConfigurator.Client(protocol);
        LOGGER.info("Connected to "+msgPiece);
        return true;
    }

    private BgpRouter() {
        bop = new BgpOp();
    }

    private static BgpRouter br = null;

    public static synchronized BgpRouter getInstance() {
        return (br == null ? br = new BgpRouter() : br);
    }

    private void dispatch(BgpOp op)
        throws TException, BgpRouterException {
        int result = 1;

        if (bgpClient == null) {
            throw new BgpRouterException(BgpRouterException.BGP_ERR_NOT_INITED);
        }

        switch (op.type) {
            case START:
                result = bgpClient.startBgp(op.ints[0], op.strs[0],
                    op.ignore, op.ignore, op.ignore, op.ints[1], op.add);
                break;
            case STOP:
                result = bgpClient.stopBgp(op.ints[0]);
                break;
            case NBR:
                result = bop.add ? 
                           bgpClient.createPeer(op.strs[0], op.ints[0]) 
                           : bgpClient.deletePeer(op.strs[0]); 
                break;
            case VRF:
                result = bop.add ? 
                           bgpClient.addVrf(op.strs[0], op.irts, op.erts)
                           : bgpClient.delVrf(op.strs[0]);
                break;
            case PFX:
                // order of args is different in addPrefix(), hence the
                // seeming out-of-order-ness of string indices
                result = bop.add ? 
                           bgpClient.pushRoute(op.strs[1], op.strs[2], 
                                                op.strs[0], op.ints[0])
                      : bgpClient.withdrawRoute(op.strs[1], op.strs[0]);
                break;
            case LOG:
                result = bgpClient.setLogConfig(op.strs[0], op.strs[1]);
                break;
            case MHOP: 
                result = bop.add ? 
                      bgpClient.setEbgpMultihop(op.strs[0], op.ints[0])
                      : bgpClient.unsetEbgpMultihop(op.strs[0]);
                break;
            case SRC: 
                result = bop.add ?
                      bgpClient.setUpdateSource(op.strs[0], op.strs[1])
                      : bgpClient.unsetUpdateSource(op.strs[0]);
                break;
            default: break;
            case AF: 
                af_afi afi = af_afi.findByValue(op.ints[0]);
                af_safi safi = af_safi.findByValue(op.ints[1]);
                result = bop.add ?
                  bgpClient.enableAddressFamily(op.strs[0], afi, safi)
                  : bgpClient.disableAddressFamily(op.strs[0], afi, safi);
                break;
            case GR: 
                result = bop.add ?
                           bgpClient.enableGracefulRestart(op.ints[0])
                           : bgpClient.disableGracefulRestart();
                break;
        }
        if (result != 0) {
            throw new BgpRouterException(result);
        }
    }

    public synchronized void startBgp(int asNum, String rtrId, int stalepathTime,
                         boolean announceFbit)
        throws TException, BgpRouterException {
        bop.type = Optype.START;
        bop.add = announceFbit;
        bop.ints[0] = asNum;
        bop.ints[1] = stalepathTime;
        bop.strs[0] = rtrId;
        LOGGER.debug("Starting BGP with as number {} and router ID {} ", asNum, rtrId);
        dispatch(bop);
    }

    public synchronized void stopBgp(int asNum)
        throws TException, BgpRouterException {
        bop.type = Optype.STOP;
        bop.ints[0] = asNum;
        LOGGER.debug("Stopping BGP with as number {}", asNum);
        dispatch(bop);
    }

    public synchronized void addNeighbor(String nbrIp, int nbrAsNum)
        throws TException, BgpRouterException {
        bop.type = Optype.NBR;
        bop.add = true;
        bop.strs[0] = nbrIp;
        bop.ints[0] = nbrAsNum;
        LOGGER.debug("Adding BGP Neighbor {} with as number {} ", nbrIp, nbrAsNum);
        dispatch(bop);
    }

    public synchronized void delNeighbor(String nbrIp)
        throws TException, BgpRouterException {
        bop.type = Optype.NBR;
        bop.add = false;
        bop.strs[0] = nbrIp;
        LOGGER.debug("Deleting BGP Neighbor {} ", nbrIp);
        dispatch(bop);
    }

    public synchronized void addVrf(String rd, List<String> irts, List<String> erts)
        throws TException, BgpRouterException {
        bop.type = Optype.VRF;
        bop.add = true;
        bop.strs[0] = rd;
        bop.irts = irts;
        bop.erts = erts;
        LOGGER.debug("Adding BGP VRF rd: {} ", rd);
        dispatch(bop);
    }

    public synchronized void delVrf(String rd)
        throws TException, BgpRouterException {
        bop.type = Optype.VRF;
        bop.add = false;
        bop.strs[0] = rd;
        LOGGER.debug("Deleting BGP VRF rd: {} " + rd);
        dispatch(bop);
    }

    // bit of a mess-up: the order of arguments is different in
    // the Thrift RPC: prefix-nexthop-rd-label. 

    public synchronized void addPrefix(String rd, String prefix, String nexthop, int label)
        throws TException, BgpRouterException {
        bop.type = Optype.PFX;
        bop.add = true;
        bop.strs[0] = rd;
        bop.strs[1] = prefix;
        bop.strs[2] = nexthop;
        bop.ints[0] = label;
        LOGGER.debug("Adding BGP route - rd:{} prefix:{} nexthop:{} label:{} ", rd ,prefix, nexthop, label);
        dispatch(bop);
    }

    public synchronized void delPrefix(String rd, String prefix)
        throws TException, BgpRouterException {
        bop.type = Optype.PFX;
        bop.add = false;
        bop.strs[0] = rd;
        bop.strs[1] = prefix;
        LOGGER.debug("Deleting BGP route - rd:{} prefix:{} ", rd, prefix);
        dispatch(bop);
    }

    public int initRibSync(BgpSyncHandle handle)
        throws TException, BgpRouterException {
        if (bgpClient == null) {
            throw new BgpRouterException(BgpRouterException.BGP_ERR_NOT_INITED);
        }
        if (handle.getState() == BgpSyncHandle.ITERATING) {
            return BgpRouterException.BGP_ERR_IN_ITER;
        }
        handle.setState(BgpSyncHandle.INITED);
        handle.setMore(1);
        return 0;
    }

    public int endRibSync(BgpSyncHandle handle)
        throws TException, BgpRouterException {
        if (bgpClient == null) {
            throw new BgpRouterException(BgpRouterException.BGP_ERR_NOT_INITED);
        }
        int state = handle.getState();
        switch (state) {
            case BgpSyncHandle.INITED:
            case BgpSyncHandle.ITERATING:
                handle.setState(BgpSyncHandle.ABORTED);
                break;
            case BgpSyncHandle.DONE:
                break;
            case BgpSyncHandle.NEVER_DONE:
                return BgpRouterException.BGP_ERR_NOT_ITER;
            default:
                break;
        }
        return 0;
    }

    public Routes doRibSync(BgpSyncHandle handle)
        throws TException, BgpRouterException {
        if (bgpClient == null) {
            throw new BgpRouterException(BgpRouterException.BGP_ERR_NOT_INITED);
        }
        int state = handle.getState();
        if (state != BgpSyncHandle.INITED && state != BgpSyncHandle.ITERATING) {
            Routes r = new Routes();
            r.setErrcode(BgpRouterException.BGP_ERR_NOT_ITER);
            return r;
        }
        int op = (state == BgpSyncHandle.INITED) ?
            GET_RTS_INIT : GET_RTS_NEXT;
        handle.setState(BgpSyncHandle.ITERATING);
        int winSize = handle.getMaxCount()*handle.getRouteSize();
        Routes outRoutes = bgpClient.getRoutes(op, winSize);
       if (outRoutes.errcode != 0) {
           return outRoutes;
       }
        handle.setMore(outRoutes.more);
        if (outRoutes.more == 0) {
            handle.setState(BgpSyncHandle.DONE);
        }
        return outRoutes;
    }

    public synchronized void setLogging(String fileName, String debugLevel)
            throws TException, BgpRouterException {
        bop.type = Optype.LOG;
        bop.strs[0] = fileName;
        bop.strs[1] = debugLevel;
        LOGGER.debug("Setting Log file to BGP VRF rd: {} ", fileName, debugLevel);
        dispatch(bop);
    }

    public synchronized void addEbgpMultihop(String nbrIp, int nhops)
        throws TException, BgpRouterException {
        bop.type = Optype.MHOP;
        bop.add = true;
        bop.strs[0] = nbrIp;
        bop.ints[0] = nhops;
        LOGGER.debug("ebgp-multihop set for peer {}, num hops = {}",
                      nbrIp, nhops);
        dispatch(bop);
    }

    public synchronized void delEbgpMultihop(String nbrIp)
        throws TException, BgpRouterException {
        bop.type = Optype.MHOP;
        bop.add = false;
        bop.strs[0] = nbrIp;
        LOGGER.debug("ebgp-multihop deleted for peer {}", nbrIp);
        dispatch(bop);
    }

    public synchronized void addUpdateSource(String nbrIp, String srcIp)
        throws TException, BgpRouterException {
        bop.type = Optype.SRC;
        bop.add = true;
        bop.strs[0] = nbrIp;
        bop.strs[1] = srcIp;
        LOGGER.debug("update-source added for peer {}, src-ip = {}", 
                      nbrIp, srcIp);
        dispatch(bop);
    }

    public synchronized void delUpdateSource(String nbrIp)
        throws TException, BgpRouterException {
        bop.type = Optype.SRC;
        bop.add = false;
        bop.strs[0] = nbrIp;
        LOGGER.debug("update-source deleted for peer {}", nbrIp);
        dispatch(bop);
    }

    public synchronized void addAddressFamily(String nbrIp, 
                                  af_afi afi, af_safi safi)
        throws TException, BgpRouterException {
        bop.type = Optype.AF;
        bop.add = true;
        bop.strs[0] = nbrIp;
        bop.ints[0] = afi.getValue();
        bop.ints[1] = safi.getValue();
        LOGGER.debug("addr family added for peer {}, afi = {}, safi = {}",
                     nbrIp, bop.ints[0], bop.ints[1]);
        dispatch(bop);
    }

    public synchronized void delAddressFamily(String nbrIp,
                                  af_afi afi, af_safi safi)
        throws TException, BgpRouterException {
        bop.type = Optype.AF;
        bop.add = false;
        bop.strs[0] = nbrIp;
        bop.ints[0] = afi.getValue();
        bop.ints[1] = safi.getValue();
        LOGGER.debug("addr family deleted for peer {}, afi = {}, safi = {}",
                     nbrIp, bop.ints[0], bop.ints[1]);
        dispatch(bop);
    }

    public synchronized void addGracefulRestart(int stalepathTime)
        throws TException, BgpRouterException {
        bop.type = Optype.GR;
        bop.add = true;
        bop.ints[0] = stalepathTime;
        LOGGER.debug("graceful restart added, stale-path-time = {}",
                      stalepathTime);
        dispatch(bop);
    }

    public synchronized void delGracefulRestart()
        throws TException, BgpRouterException {
        bop.type = Optype.GR;
        bop.add = false;
        LOGGER.debug("graceful restart deleted");
        dispatch(bop);
    }
}