package main

import (
	"encoding/hex"
	"fmt"
	"log"
	"net"
	"strings"

	"github.com/btcsuite/btcd/chaincfg"

	"github.com/btcsuite/btcd/btcec"
	"github.com/btcsuite/btcutil"
	"github.com/btcsuite/btcwallet/waddrmgr"
	"github.com/lightningnetwork/lnd/lndc"
	"github.com/lightningnetwork/lnd/lnrpc"
	"github.com/lightningnetwork/lnd/lnwallet"
	"github.com/lightningnetwork/lnd/lnwire"
	"golang.org/x/net/context"
)

var (
	defaultAccount uint32 = waddrmgr.DefaultAccountNum
)

// rpcServer...
type rpcServer struct { // doesn't count as globals I think
	lnwallet *lnwallet.LightningWallet // interface to the bitcoin network
	CnMap    map[[16]byte]net.Conn     //interface to the lightning network
	OmniChan chan []byte               // channel for all incoming messages from LN nodes.
	// can split the OmniChan up if that is helpful.  So far 1 seems OK.
}

type LNAdr struct {
	LNId   [16]byte // redundant because adr contains it
	Adr    btcutil.Address
	PubKey *btcec.PublicKey

	Name        string
	Host        string
	Endorsement []byte
}

func (l *LNAdr) ParseFromString(s string) error {
	var err error
	if len(s) == 0 {
		return fmt.Errorf("LNid ParseFromString: null string")
	}
	if l == nil { // make a LNId if it doesn't exist
		return fmt.Errorf("null id, initialize first")
	}

	ss := strings.Split(s, "@")
	ident := ss[0]
	if len(ss) > 1 { // redundant? no
		l.Host = ss[1]
	}
	if len(ident) > 65 && len(ident) < 69 { // could be pubkey
		pubkeyBytes, err := hex.DecodeString(ident)
		if err != nil {
			return err
		}
		l.PubKey, err = btcec.ParsePubKey(pubkeyBytes, btcec.S256())
		if err != nil {
			return err
		}

		// got pubey, populate address from pubkey
		l.Adr, err = btcutil.NewAddressPubKeyHash(btcutil.Hash160(
			l.PubKey.SerializeCompressed()), &chaincfg.TestNet3Params)
		if err != nil {
			return err
		}
	} else if len(ident) > 33 && len(ident) < 37 { // could be pkh
		l.Adr, err = btcutil.DecodeAddress(
			ident, &chaincfg.TestNet3Params)
		if err != nil {
			return err
		}
	} else {
		return fmt.Errorf("invalid address %s", ident)
	}

	// check for nonstandard port
	//	if strings.Count(lid.Host, ":") == 1 {
	//	}
	//don't for now... stdlib should do this.  ipv6 and stuff...

	//	populate LNId from address
	copy(l.LNId[:], l.Adr.ScriptAddress())
	return nil
}

var _ lnrpc.LightningServer = (*rpcServer)(nil)

// newRpcServer...
func newRpcServer(wallet *lnwallet.LightningWallet) *rpcServer {
	return &rpcServer{wallet,
		make(map[[16]byte]net.Conn), // initialize with empty CnMap
		make(chan []byte)}           // init OmniChan (size 1 ok...?)
}

// Stop...
func (r *rpcServer) Stop() error {
	return nil
}

// getPriv gets the identity private key out of the wallet DB
func getPriv(l *lnwallet.LightningWallet) (*btcec.PrivateKey, error) {
	adr, err := l.ChannelDB.GetIdAdr()
	if err != nil {
		return nil, err
	}
	fmt.Printf("got ID address: %s\n", adr.String())
	adr2, err := l.Manager.Address(adr)
	if err != nil {
		return nil, err
	}
	priv, err := adr2.(waddrmgr.ManagedPubKeyAddress).PrivKey()
	if err != nil {
		return nil, err
	}
	fmt.Printf("got privkey %x\n", priv.Serialize()) // may want to remove this :)
	return priv, nil
}

// SendMany...
func (r *rpcServer) SendMany(ctx context.Context, in *lnrpc.SendManyRequest) (*lnrpc.SendManyResponse, error) {

	sendMap := make(map[string]btcutil.Amount)
	for addr, amt := range in.AddrToAmount {
		sendMap[addr] = btcutil.Amount(amt)
	}

	txid, err := r.lnwallet.SendPairs(sendMap, defaultAccount, 1)
	if err != nil {
		return nil, err
	}

	return &lnrpc.SendManyResponse{Txid: hex.EncodeToString(txid[:])}, nil
}

// NewAddress...
func (r *rpcServer) NewAddress(ctx context.Context, in *lnrpc.NewAddressRequest) (*lnrpc.NewAddressResponse, error) {

	r.lnwallet.KeyGenMtx.Lock()
	defer r.lnwallet.KeyGenMtx.Unlock()

	addr, err := r.lnwallet.NewAddress(defaultAccount)
	if err != nil {
		return nil, err
	}

	return &lnrpc.NewAddressResponse{Address: addr.String()}, nil
}

// LNConnect
func (r *rpcServer) LNConnect(ctx context.Context,
	in *lnrpc.LNConnectRequest) (*lnrpc.LnConnectResponse, error) {

	var err error

	if len(in.IdAtHost) == 0 {
		return nil, fmt.Errorf("need: lnc pubkeyhash@hostname")
	}
	var newNode LNAdr

	err = newNode.ParseFromString(in.IdAtHost)
	if err != nil {
		return nil, err
	}
	if _, ok := r.CnMap[newNode.LNId]; ok {
		return nil, fmt.Errorf("Already connected to %x", newNode.LNId)
	}
	if newNode.Host == "" { // do PBX connect; leave for now
		return nil, fmt.Errorf("no hostname")
	}
	priv, err := getPriv(r.lnwallet)
	if err != nil {
		return nil, err
	}

	// dial TCP
	newConn := new(lndc.LNDConn)
	newConn.Cn, err = net.Dial("tcp", newNode.Host+":"+"2448")
	if err != nil {
		return nil, err
	}
	// TODO differentiate; right now only uses PKH
	if newNode.PubKey != nil { // have pubkey, use that
		err = newConn.Open(priv, newNode.Adr.ScriptAddress())
		if err != nil {
			return nil, err
		}
	} else { // only have address (pubkey hash), use that
		err = newConn.Open(priv, newNode.Adr.ScriptAddress())
		if err != nil {
			return nil, err
		}
	}

	idslice := lndc.H160(newConn.RemotePub.SerializeCompressed())
	var newId [16]byte
	copy(newId[:], idslice[:16])
	r.CnMap[newId] = newConn
	log.Printf("added %x to map\n", newId)

	go LNDCReceiver(newConn, newId, r)

	resp := new(lnrpc.LnConnectResponse)
	resp.LnID = newId[:]
	return resp, nil
}

// TCPListen
func (r *rpcServer) TCPListen(ctx context.Context,
	in *lnrpc.TCPListenRequest) (*lnrpc.TCPListenResponse, error) {
	// LnListen listens on the default port for incoming connections
	//ignore args and launch listener goroutine
	priv, err := getPriv(r.lnwallet)
	if err != nil {
		return nil, err
	}

	go TCPListener(priv, r)

	resp := new(lnrpc.TCPListenResponse)
	return resp, nil
}

// LNChat
func (r *rpcServer) LNChat(ctx context.Context,
	in *lnrpc.LnChatRequest) (*lnrpc.LnChatResponse, error) {
	log.Printf("requested to chat, message: %s\n", in.Msg)

	var dest [16]byte
	if len(in.DestID) != 16 {
		return nil, fmt.Errorf("Expect 16 byte destination Id, got %d byte",
			len(in.DestID))
	}
	copy(dest[:], in.DestID)
	if len(in.Msg) == 0 {
		return nil, fmt.Errorf("you have to say something")
	}
	if len(r.CnMap) == 0 { // This check is redundant.  May still help though.
		return nil, fmt.Errorf("Not connected to anyone")
	}
	if _, ok := r.CnMap[dest]; !ok {
		return nil, fmt.Errorf("dest %x not connected", dest)
	}

	msg := append([]byte{lnwire.MSGID_TEXTCHAT}, []byte(in.Msg)...)

	_, err := r.CnMap[dest].Write(msg)
	if err != nil {
		return nil, err
	}

	resp := new(lnrpc.LnChatResponse)
	return resp, nil
}

func TCPListener(priv *btcec.PrivateKey, r *rpcServer) {
	listener, err := net.Listen("tcp", ":"+"2448")
	if err != nil {
		fmt.Printf("TCP listen error: %s\n", err.Error())
		return
	}

	fmt.Printf("Listening on %s\n", listener.Addr().String())
	for {
		con, err := listener.Accept() // this blocks
		if err != nil {
			log.Printf("Listener error: %s\n", err.Error())
			continue
		}
		newConn, err := InitIncomingConn(priv, con)
		if err != nil {
			fmt.Printf("InitConn error: %s\n", err.Error())
			continue
		}
		idslice := lndc.H160(newConn.RemotePub.SerializeCompressed())
		var newId [16]byte
		copy(newId[:], idslice[:16])
		r.CnMap[newId] = newConn
		fmt.Printf("added %x to map\n", newId)

		go LNDCReceiver(newConn, newId, r)
	}
}

func InitIncomingConn(priv *btcec.PrivateKey, con net.Conn) (*lndc.LNDConn, error) {
	LNcon := new(lndc.LNDConn)
	LNcon.Cn = con
	err := LNcon.Setup(priv)
	if err != nil {
		return LNcon, err
	}
	fmt.Printf("Got connection from %s authed with pubkey %x",
		LNcon.Cn.RemoteAddr().String(), LNcon.RemotePub.SerializeCompressed())
	return LNcon, nil

}