// Copyright (C) 2016 Nippon Telegraph and Telephone Corporation.
//
// 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 client provides a wrapper for GoBGP's gRPC API
package client

import (
	"fmt"
	"io"
	"net"
	"strconv"
	"time"

	"golang.org/x/net/context"
	"google.golang.org/grpc"

	api "github.com/osrg/gobgp/api"
	"github.com/osrg/gobgp/internal/pkg/config"
	"github.com/osrg/gobgp/pkg/packet/bgp"
	"github.com/osrg/gobgp/pkg/server"
)

type Client struct {
	conn *grpc.ClientConn
	cli  api.GobgpApiClient
}

func defaultGRPCOptions() []grpc.DialOption {
	return []grpc.DialOption{grpc.WithTimeout(time.Second), grpc.WithBlock(), grpc.WithInsecure()}
}

// New returns a new Client using the given target and options for dialing
// to the grpc server. If an error occurs during dialing it will be returned and
// Client will be nil.
func New(target string, opts ...grpc.DialOption) (*Client, error) {
	return NewWith(context.Background(), target, opts...)
}

// NewWith is like New, but uses the given ctx to cancel or expire the current
// attempt to connect if it becomes Done before the connection succeeds.
func NewWith(ctx context.Context, target string, opts ...grpc.DialOption) (*Client, error) {
	if target == "" {
		target = ":50051"
	}
	if len(opts) == 0 {
		opts = defaultGRPCOptions()
	}
	conn, err := grpc.DialContext(ctx, target, opts...)
	if err != nil {
		return nil, err
	}
	cli := api.NewGobgpApiClient(conn)
	return &Client{conn: conn, cli: cli}, nil
}

// NewFrom returns a new Client, using the given conn and cli for the
// underlying connection. The given grpc.ClientConn connection is expected to be
// initialized and paired with the api client. See New to have the connection
// dialed for you.
func NewFrom(conn *grpc.ClientConn, cli api.GobgpApiClient) *Client {
	return &Client{conn: conn, cli: cli}
}

func (cli *Client) Close() error {
	return cli.conn.Close()
}

func (cli *Client) StartServer(c *config.Global) error {
	_, err := cli.cli.StartServer(context.Background(), &api.StartServerRequest{
		Global: &api.Global{
			As:               c.Config.As,
			RouterId:         c.Config.RouterId,
			ListenPort:       c.Config.Port,
			ListenAddresses:  c.Config.LocalAddressList,
			UseMultiplePaths: c.UseMultiplePaths.Config.Enabled,
		},
	})
	return err
}

func (cli *Client) StopServer() error {
	_, err := cli.cli.StopServer(context.Background(), &api.StopServerRequest{})
	return err
}

func (cli *Client) GetServer() (*config.Global, error) {
	ret, err := cli.cli.GetServer(context.Background(), &api.GetServerRequest{})
	if err != nil {
		return nil, err
	}
	return &config.Global{
		Config: config.GlobalConfig{
			As:               ret.Global.As,
			RouterId:         ret.Global.RouterId,
			Port:             ret.Global.ListenPort,
			LocalAddressList: ret.Global.ListenAddresses,
		},
		UseMultiplePaths: config.UseMultiplePaths{
			Config: config.UseMultiplePathsConfig{
				Enabled: ret.Global.UseMultiplePaths,
			},
		},
	}, nil
}

func (cli *Client) EnableZebra(c *config.Zebra) error {
	req := &api.EnableZebraRequest{
		Url:                  c.Config.Url,
		Version:              uint32(c.Config.Version),
		NexthopTriggerEnable: c.Config.NexthopTriggerEnable,
		NexthopTriggerDelay:  uint32(c.Config.NexthopTriggerDelay),
	}
	for _, t := range c.Config.RedistributeRouteTypeList {
		req.RouteTypes = append(req.RouteTypes, string(t))
	}
	_, err := cli.cli.EnableZebra(context.Background(), req)
	return err
}

func (cli *Client) getNeighbor(name string, afi int, vrf string, enableAdvertised bool) ([]*config.Neighbor, error) {
	ret, err := cli.cli.GetNeighbor(context.Background(), &api.GetNeighborRequest{EnableAdvertised: enableAdvertised, Address: name})
	if err != nil {
		return nil, err
	}

	neighbors := make([]*config.Neighbor, 0, len(ret.Peers))

	for _, p := range ret.Peers {
		if name != "" && name != p.Info.NeighborAddress && name != p.Conf.NeighborInterface {
			continue
		}
		if vrf != "" && name != p.Conf.Vrf {
			continue
		}
		if afi > 0 {
			v6 := net.ParseIP(p.Info.NeighborAddress).To4() == nil
			if afi == bgp.AFI_IP && v6 || afi == bgp.AFI_IP6 && !v6 {
				continue
			}
		}
		n, err := server.NewNeighborFromAPIStruct(p)
		if err != nil {
			return nil, err
		}
		neighbors = append(neighbors, n)
	}
	return neighbors, nil
}

func (cli *Client) ListNeighbor() ([]*config.Neighbor, error) {
	return cli.getNeighbor("", 0, "", false)
}

func (cli *Client) ListNeighborByTransport(afi int) ([]*config.Neighbor, error) {
	return cli.getNeighbor("", afi, "", false)
}

func (cli *Client) ListNeighborByVRF(vrf string) ([]*config.Neighbor, error) {
	return cli.getNeighbor("", 0, vrf, false)
}

func (cli *Client) GetNeighbor(name string, options ...bool) (*config.Neighbor, error) {
	enableAdvertised := false
	if len(options) > 0 && options[0] {
		enableAdvertised = true
	}
	ns, err := cli.getNeighbor(name, 0, "", enableAdvertised)
	if err != nil {
		return nil, err
	}
	if len(ns) == 0 {
		return nil, fmt.Errorf("not found neighbor %s", name)
	}
	return ns[0], nil
}

func (cli *Client) AddNeighbor(c *config.Neighbor) error {
	peer := server.NewPeerFromConfigStruct(c)
	_, err := cli.cli.AddNeighbor(context.Background(), &api.AddNeighborRequest{Peer: peer})
	return err
}

func (cli *Client) DeleteNeighbor(c *config.Neighbor) error {
	peer := server.NewPeerFromConfigStruct(c)
	_, err := cli.cli.DeleteNeighbor(context.Background(), &api.DeleteNeighborRequest{Peer: peer})
	return err
}

func (cli *Client) UpdateNeighbor(c *config.Neighbor, doSoftResetIn bool) (bool, error) {
	peer := server.NewPeerFromConfigStruct(c)
	response, err := cli.cli.UpdateNeighbor(context.Background(), &api.UpdateNeighborRequest{Peer: peer, DoSoftResetIn: doSoftResetIn})
	return response.NeedsSoftResetIn, err
}

func (cli *Client) ShutdownNeighbor(addr, communication string) error {
	_, err := cli.cli.ShutdownNeighbor(context.Background(), &api.ShutdownNeighborRequest{Address: addr, Communication: communication})
	return err
}

func (cli *Client) ResetNeighbor(addr, communication string) error {
	_, err := cli.cli.ResetNeighbor(context.Background(), &api.ResetNeighborRequest{Address: addr, Communication: communication})
	return err
}

func (cli *Client) EnableNeighbor(addr string) error {
	_, err := cli.cli.EnableNeighbor(context.Background(), &api.EnableNeighborRequest{Address: addr})
	return err
}

func (cli *Client) DisableNeighbor(addr, communication string) error {
	_, err := cli.cli.DisableNeighbor(context.Background(), &api.DisableNeighborRequest{Address: addr, Communication: communication})
	return err
}

func (cli *Client) softreset(addr string, family bgp.RouteFamily, dir api.SoftResetNeighborRequest_SoftResetDirection) error {
	_, err := cli.cli.SoftResetNeighbor(context.Background(), &api.SoftResetNeighborRequest{
		Address:   addr,
		Direction: dir,
	})
	return err
}

func (cli *Client) SoftResetIn(addr string, family bgp.RouteFamily) error {
	return cli.softreset(addr, family, api.SoftResetNeighborRequest_IN)
}

func (cli *Client) SoftResetOut(addr string, family bgp.RouteFamily) error {
	return cli.softreset(addr, family, api.SoftResetNeighborRequest_OUT)
}

func (cli *Client) SoftReset(addr string, family bgp.RouteFamily) error {
	return cli.softreset(addr, family, api.SoftResetNeighborRequest_BOTH)
}

func (cli *Client) getRIB(resource api.Resource, name string, family bgp.RouteFamily, prefixes []*api.TableLookupPrefix) (*api.Table, error) {
	stream, err := cli.cli.GetPath(context.Background(), &api.GetPathRequest{
		Type:     resource,
		Family:   uint32(family),
		Name:     name,
		Prefixes: prefixes,
	})
	if err != nil {
		return nil, err
	}
	pathMap := make(map[string][]*api.Path)
	for {
		p, err := stream.Recv()
		if err != nil {
			if err == io.EOF {
				break
			}
			return nil, err
		}
		nlri, err := p.GetNativeNlri()
		if err != nil {
			return nil, err
		}
		nlriStr := nlri.String()
		pathMap[nlriStr] = append(pathMap[nlriStr], p)
	}
	dstList := make([]*api.Destination, 0, len(pathMap))
	for _, pathList := range pathMap {
		nlri, _ := pathList[0].GetNativeNlri()
		dstList = append(dstList, &api.Destination{
			Prefix: nlri.String(),
			Paths:  pathList,
		})
	}
	return &api.Table{
		Family:       uint32(family),
		Destinations: dstList,
	}, nil
}

func (cli *Client) GetRIB(family bgp.RouteFamily, prefixes []*api.TableLookupPrefix) (*api.Table, error) {
	return cli.getRIB(api.Resource_GLOBAL, "", family, prefixes)
}

func (cli *Client) GetLocalRIB(name string, family bgp.RouteFamily, prefixes []*api.TableLookupPrefix) (*api.Table, error) {
	return cli.getRIB(api.Resource_LOCAL, name, family, prefixes)
}

func (cli *Client) GetAdjRIBIn(name string, family bgp.RouteFamily, prefixes []*api.TableLookupPrefix) (*api.Table, error) {
	return cli.getRIB(api.Resource_ADJ_IN, name, family, prefixes)
}

func (cli *Client) GetAdjRIBOut(name string, family bgp.RouteFamily, prefixes []*api.TableLookupPrefix) (*api.Table, error) {
	return cli.getRIB(api.Resource_ADJ_OUT, name, family, prefixes)
}

func (cli *Client) GetVRFRIB(name string, family bgp.RouteFamily, prefixes []*api.TableLookupPrefix) (*api.Table, error) {
	return cli.getRIB(api.Resource_VRF, name, family, prefixes)
}

func (cli *Client) getRIBInfo(resource api.Resource, name string, family bgp.RouteFamily) (*api.TableInfo, error) {
	r, err := cli.cli.GetRibInfo(context.Background(), &api.GetRibInfoRequest{
		Info: &api.TableInfo{
			Type:   resource,
			Name:   name,
			Family: uint32(family),
		},
	})
	if err != nil {
		return nil, err
	} else {
		return r.Info, nil
	}
}

func (cli *Client) GetRIBInfo(family bgp.RouteFamily) (*api.TableInfo, error) {
	return cli.getRIBInfo(api.Resource_GLOBAL, "", family)
}

func (cli *Client) GetLocalRIBInfo(name string, family bgp.RouteFamily) (*api.TableInfo, error) {
	return cli.getRIBInfo(api.Resource_LOCAL, name, family)
}

func (cli *Client) GetAdjRIBInInfo(name string, family bgp.RouteFamily) (*api.TableInfo, error) {
	return cli.getRIBInfo(api.Resource_ADJ_IN, name, family)
}

func (cli *Client) GetAdjRIBOutInfo(name string, family bgp.RouteFamily) (*api.TableInfo, error) {
	return cli.getRIBInfo(api.Resource_ADJ_OUT, name, family)
}

type AddPathByStreamClient struct {
	stream api.GobgpApi_InjectMrtClient
}

func (c *AddPathByStreamClient) Send(paths ...*api.Path) error {
	return c.stream.Send(&api.InjectMrtRequest{
		Resource: api.Resource_GLOBAL,
		Paths:    paths,
	})
}

func (c *AddPathByStreamClient) Close() error {
	_, err := c.stream.CloseAndRecv()
	return err
}

func (cli *Client) AddPathByStream() (*AddPathByStreamClient, error) {
	stream, err := cli.cli.InjectMrt(context.Background())
	if err != nil {
		return nil, err
	}
	return &AddPathByStreamClient{stream}, nil
}

func (cli *Client) addPath(vrfID string, pathList []*api.Path) ([]byte, error) {
	resource := api.Resource_GLOBAL
	if vrfID != "" {
		resource = api.Resource_VRF
	}
	var uuid []byte
	for _, path := range pathList {
		r, err := cli.cli.AddPath(context.Background(), &api.AddPathRequest{
			Resource: resource,
			VrfId:    vrfID,
			Path:     path,
		})
		if err != nil {
			return nil, err
		}
		uuid = r.Uuid
	}
	return uuid, nil
}

func (cli *Client) AddPath(pathList []*api.Path) ([]byte, error) {
	return cli.addPath("", pathList)
}

func (cli *Client) AddVRFPath(vrfID string, pathList []*api.Path) ([]byte, error) {
	if vrfID == "" {
		return nil, fmt.Errorf("VRF ID is empty")
	}
	return cli.addPath(vrfID, pathList)
}

func (cli *Client) deletePath(uuid []byte, f bgp.RouteFamily, vrfID string, pathList []*api.Path) error {
	var reqs []*api.DeletePathRequest

	resource := api.Resource_GLOBAL
	if vrfID != "" {
		resource = api.Resource_VRF
	}
	switch {
	case len(pathList) != 0:
		for _, path := range pathList {
			reqs = append(reqs, &api.DeletePathRequest{
				Resource: resource,
				VrfId:    vrfID,
				Path:     path,
			})
		}
	default:
		reqs = append(reqs, &api.DeletePathRequest{
			Resource: resource,
			VrfId:    vrfID,
			Uuid:     uuid,
			Family:   uint32(f),
		})
	}

	for _, req := range reqs {
		if _, err := cli.cli.DeletePath(context.Background(), req); err != nil {
			return err
		}
	}
	return nil
}

func (cli *Client) DeletePath(pathList []*api.Path) error {
	return cli.deletePath(nil, bgp.RouteFamily(0), "", pathList)
}

func (cli *Client) DeleteVRFPath(vrfID string, pathList []*api.Path) error {
	if vrfID == "" {
		return fmt.Errorf("VRF ID is empty")
	}
	return cli.deletePath(nil, bgp.RouteFamily(0), vrfID, pathList)
}

func (cli *Client) DeletePathByUUID(uuid []byte) error {
	return cli.deletePath(uuid, bgp.RouteFamily(0), "", nil)
}

func (cli *Client) DeletePathByFamily(family bgp.RouteFamily) error {
	return cli.deletePath(nil, family, "", nil)
}

func (cli *Client) GetVRF() ([]*api.Vrf, error) {
	ret, err := cli.cli.GetVrf(context.Background(), &api.GetVrfRequest{})
	if err != nil {
		return nil, err
	}
	return ret.Vrfs, nil
}

func (cli *Client) AddVRF(name string, id int, rd bgp.RouteDistinguisherInterface, im, ex []bgp.ExtendedCommunityInterface) error {
	arg := &api.AddVrfRequest{
		Vrf: &api.Vrf{
			Name:     name,
			Rd:       api.MarshalRD(rd),
			Id:       uint32(id),
			ImportRt: api.MarshalRTs(im),
			ExportRt: api.MarshalRTs(ex),
		},
	}
	_, err := cli.cli.AddVrf(context.Background(), arg)
	return err
}

func (cli *Client) DeleteVRF(name string) error {
	arg := &api.DeleteVrfRequest{
		Vrf: &api.Vrf{
			Name: name,
		},
	}
	_, err := cli.cli.DeleteVrf(context.Background(), arg)
	return err
}

func (cli *Client) getDefinedSet(typ api.DefinedType, name string) ([]*api.DefinedSet, error) {
	ret, err := cli.cli.GetDefinedSet(context.Background(), &api.GetDefinedSetRequest{
		Type: api.DefinedType(typ),
		Name: name,
	})
	if err != nil {
		return nil, err
	}
	return ret.Sets, nil
}

func (cli *Client) GetDefinedSet(typ api.DefinedType) ([]*api.DefinedSet, error) {
	return cli.getDefinedSet(typ, "")
}

func (cli *Client) GetDefinedSetByName(typ api.DefinedType, name string) (*api.DefinedSet, error) {
	sets, err := cli.getDefinedSet(typ, name)
	if err != nil {
		return nil, err
	}
	if len(sets) == 0 {
		return nil, fmt.Errorf("not found defined set: %s", name)
	} else if len(sets) > 1 {
		return nil, fmt.Errorf("invalid response for GetDefinedSetByName")
	}
	return sets[0], nil
}

func (cli *Client) AddDefinedSet(d *api.DefinedSet) error {
	_, err := cli.cli.AddDefinedSet(context.Background(), &api.AddDefinedSetRequest{
		Set: d,
	})
	return err
}

func (cli *Client) DeleteDefinedSet(d *api.DefinedSet, all bool) error {
	_, err := cli.cli.DeleteDefinedSet(context.Background(), &api.DeleteDefinedSetRequest{
		Set: d,
		All: all,
	})
	return err
}

func (cli *Client) ReplaceDefinedSet(d *api.DefinedSet) error {
	_, err := cli.cli.ReplaceDefinedSet(context.Background(), &api.ReplaceDefinedSetRequest{
		Set: d,
	})
	return err
}

func (cli *Client) GetStatement() ([]*api.Statement, error) {
	ret, err := cli.cli.GetStatement(context.Background(), &api.GetStatementRequest{})
	if err != nil {
		return nil, err
	}
	return ret.Statements, nil
}

func (cli *Client) AddStatement(t *api.Statement) error {
	_, err := cli.cli.AddStatement(context.Background(), &api.AddStatementRequest{
		Statement: t,
	})
	return err
}

func (cli *Client) DeleteStatement(t *api.Statement, all bool) error {
	_, err := cli.cli.DeleteStatement(context.Background(), &api.DeleteStatementRequest{
		Statement: t,
		All:       all,
	})
	return err
}

func (cli *Client) ReplaceStatement(t *api.Statement) error {
	_, err := cli.cli.ReplaceStatement(context.Background(), &api.ReplaceStatementRequest{
		Statement: t,
	})
	return err
}

func (cli *Client) GetPolicy() ([]*api.Policy, error) {
	ret, err := cli.cli.GetPolicy(context.Background(), &api.GetPolicyRequest{})
	if err != nil {
		return nil, err
	}
	return ret.Policies, nil
}

func (cli *Client) AddPolicy(a *api.Policy, refer bool) error {
	_, err := cli.cli.AddPolicy(context.Background(), &api.AddPolicyRequest{
		Policy:                  a,
		ReferExistingStatements: refer,
	})
	return err
}

func (cli *Client) DeletePolicy(a *api.Policy, all, preserve bool) error {
	_, err := cli.cli.DeletePolicy(context.Background(), &api.DeletePolicyRequest{
		Policy:             a,
		All:                all,
		PreserveStatements: preserve,
	})
	return err
}

func (cli *Client) ReplacePolicy(a *api.Policy, refer, preserve bool) error {
	_, err := cli.cli.ReplacePolicy(context.Background(), &api.ReplacePolicyRequest{
		Policy:                  a,
		ReferExistingStatements: refer,
		PreserveStatements:      preserve,
	})
	return err
}

func (cli *Client) getPolicyAssignment(name string, typ api.PolicyType) (*api.PolicyAssignment, error) {
	resource := api.Resource_GLOBAL
	if name != "" {
		resource = api.Resource_LOCAL
	}

	ret, err := cli.cli.GetPolicyAssignment(context.Background(), &api.GetPolicyAssignmentRequest{
		Assignment: &api.PolicyAssignment{
			Name:     name,
			Resource: resource,
			Type:     typ,
		},
	})
	if err != nil {
		return nil, err
	}

	return &api.PolicyAssignment{
		Name:     name,
		Type:     typ,
		Policies: ret.Assignment.Policies,
		Default:  ret.Assignment.Default,
	}, nil
}

func (cli *Client) GetImportPolicy() (*api.PolicyAssignment, error) {
	return cli.getPolicyAssignment("", api.PolicyType_IMPORT)
}

func (cli *Client) GetExportPolicy() (*api.PolicyAssignment, error) {
	return cli.getPolicyAssignment("", api.PolicyType_EXPORT)
}

func (cli *Client) GetRouteServerImportPolicy(name string) (*api.PolicyAssignment, error) {
	return cli.getPolicyAssignment(name, api.PolicyType_IMPORT)
}

func (cli *Client) GetRouteServerExportPolicy(name string) (*api.PolicyAssignment, error) {
	return cli.getPolicyAssignment(name, api.PolicyType_EXPORT)
}

func (cli *Client) AddPolicyAssignment(assignment *api.PolicyAssignment) error {
	_, err := cli.cli.AddPolicyAssignment(context.Background(), &api.AddPolicyAssignmentRequest{
		Assignment: assignment,
	})
	return err
}

func (cli *Client) DeletePolicyAssignment(assignment *api.PolicyAssignment, all bool) error {
	_, err := cli.cli.DeletePolicyAssignment(context.Background(), &api.DeletePolicyAssignmentRequest{
		Assignment: assignment,
		All:        all})
	return err
}

func (cli *Client) ReplacePolicyAssignment(assignment *api.PolicyAssignment) error {
	_, err := cli.cli.ReplacePolicyAssignment(context.Background(), &api.ReplacePolicyAssignmentRequest{
		Assignment: assignment,
	})
	return err
}

//func (cli *Client) EnableMrt(c *config.MrtConfig) error {
//}
//
//func (cli *Client) DisableMrt(c *config.MrtConfig) error {
//}
//

func (cli *Client) GetRPKI() ([]*config.RpkiServer, error) {
	rsp, err := cli.cli.GetRpki(context.Background(), &api.GetRpkiRequest{})
	if err != nil {
		return nil, err
	}
	servers := make([]*config.RpkiServer, 0, len(rsp.Servers))
	for _, s := range rsp.Servers {
		// Note: RpkiServerConfig.Port is uint32 type, but the TCP/UDP port is
		// 16-bit length.
		port, err := strconv.ParseUint(s.Conf.RemotePort, 10, 16)
		if err != nil {
			return nil, err
		}
		server := &config.RpkiServer{
			Config: config.RpkiServerConfig{
				Address: s.Conf.Address,
				Port:    uint32(port),
			},
			State: config.RpkiServerState{
				Up:           s.State.Up,
				SerialNumber: s.State.Serial,
				RecordsV4:    s.State.RecordIpv4,
				RecordsV6:    s.State.RecordIpv6,
				PrefixesV4:   s.State.PrefixIpv4,
				PrefixesV6:   s.State.PrefixIpv6,
				Uptime:       s.State.Uptime,
				Downtime:     s.State.Downtime,
				RpkiMessages: config.RpkiMessages{
					RpkiReceived: config.RpkiReceived{
						SerialNotify:  s.State.SerialNotify,
						CacheReset:    s.State.CacheReset,
						CacheResponse: s.State.CacheResponse,
						Ipv4Prefix:    s.State.ReceivedIpv4,
						Ipv6Prefix:    s.State.ReceivedIpv6,
						EndOfData:     s.State.EndOfData,
						Error:         s.State.Error,
					},
					RpkiSent: config.RpkiSent{
						SerialQuery: s.State.SerialQuery,
						ResetQuery:  s.State.ResetQuery,
					},
				},
			},
		}
		servers = append(servers, server)
	}
	return servers, nil
}

func (cli *Client) GetROA(family bgp.RouteFamily) ([]*api.Roa, error) {
	rsp, err := cli.cli.GetRoa(context.Background(), &api.GetRoaRequest{
		Family: uint32(family),
	})
	if err != nil {
		return nil, err
	}
	return rsp.Roas, nil
}

func (cli *Client) AddRPKIServer(address string, port, lifetime int) error {
	_, err := cli.cli.AddRpki(context.Background(), &api.AddRpkiRequest{
		Address:  address,
		Port:     uint32(port),
		Lifetime: int64(lifetime),
	})
	return err
}

func (cli *Client) DeleteRPKIServer(address string) error {
	_, err := cli.cli.DeleteRpki(context.Background(), &api.DeleteRpkiRequest{
		Address: address,
	})
	return err
}

func (cli *Client) EnableRPKIServer(address string) error {
	_, err := cli.cli.EnableRpki(context.Background(), &api.EnableRpkiRequest{
		Address: address,
	})
	return err
}

func (cli *Client) DisableRPKIServer(address string) error {
	_, err := cli.cli.DisableRpki(context.Background(), &api.DisableRpkiRequest{
		Address: address,
	})
	return err
}

func (cli *Client) ResetRPKIServer(address string) error {
	_, err := cli.cli.ResetRpki(context.Background(), &api.ResetRpkiRequest{
		Address: address,
	})
	return err
}

func (cli *Client) SoftResetRPKIServer(address string) error {
	_, err := cli.cli.SoftResetRpki(context.Background(), &api.SoftResetRpkiRequest{
		Address: address,
	})
	return err
}

func (cli *Client) ValidateRIBWithRPKI(prefixes ...string) error {
	req := &api.ValidateRibRequest{}
	if len(prefixes) > 1 {
		return fmt.Errorf("too many prefixes: %d", len(prefixes))
	} else if len(prefixes) == 1 {
		req.Prefix = prefixes[0]
	}
	_, err := cli.cli.ValidateRib(context.Background(), req)
	return err
}

func (cli *Client) AddBMP(c *config.BmpServerConfig) error {
	_, err := cli.cli.AddBmp(context.Background(), &api.AddBmpRequest{
		Address: c.Address,
		Port:    c.Port,
		Type:    api.AddBmpRequest_MonitoringPolicy(c.RouteMonitoringPolicy.ToInt()),
	})
	return err
}

func (cli *Client) DeleteBMP(c *config.BmpServerConfig) error {
	_, err := cli.cli.DeleteBmp(context.Background(), &api.DeleteBmpRequest{
		Address: c.Address,
		Port:    c.Port,
	})
	return err
}

type MonitorRIBClient struct {
	stream api.GobgpApi_MonitorRibClient
}

func (c *MonitorRIBClient) Recv() (*api.Destination, error) {
	return c.stream.Recv()
}

func (cli *Client) MonitorRIB(family bgp.RouteFamily, current bool) (*MonitorRIBClient, error) {
	stream, err := cli.cli.MonitorRib(context.Background(), &api.MonitorRibRequest{
		Table: &api.Table{
			Type:   api.Resource_GLOBAL,
			Family: uint32(family),
		},
		Current: current,
	})
	if err != nil {
		return nil, err
	}
	return &MonitorRIBClient{stream}, nil
}

func (cli *Client) MonitorAdjRIBIn(name string, family bgp.RouteFamily, current bool) (*MonitorRIBClient, error) {
	stream, err := cli.cli.MonitorRib(context.Background(), &api.MonitorRibRequest{
		Table: &api.Table{
			Type:   api.Resource_ADJ_IN,
			Name:   name,
			Family: uint32(family),
		},
		Current: current,
	})
	if err != nil {
		return nil, err
	}
	return &MonitorRIBClient{stream}, nil
}

type MonitorNeighborStateClient struct {
	stream api.GobgpApi_MonitorPeerStateClient
}

func (c *MonitorNeighborStateClient) Recv() (*config.Neighbor, error) {
	p, err := c.stream.Recv()
	if err != nil {
		return nil, err
	}
	return server.NewNeighborFromAPIStruct(p)
}

func (cli *Client) MonitorNeighborState(name string, current bool) (*MonitorNeighborStateClient, error) {
	stream, err := cli.cli.MonitorPeerState(context.Background(), &api.Arguments{
		Name:    name,
		Current: current,
	})
	if err != nil {
		return nil, err
	}
	return &MonitorNeighborStateClient{stream}, nil
}