package connections

import (
	"crypto/rsa"
	"git.mascherari.press/cwtch/model"
	"git.mascherari.press/cwtch/peer/peer"
	"git.mascherari.press/cwtch/protocol"
	"github.com/s-rah/go-ricochet"
	"github.com/s-rah/go-ricochet/channels"
	"github.com/s-rah/go-ricochet/connection"
	"github.com/s-rah/go-ricochet/identity"
	"github.com/s-rah/go-ricochet/utils"
	"net"
	"testing"
	"time"
)

func PeerAuthValid(hostname string, publicKey rsa.PublicKey) (allowed, known bool) {
	return true, true
}

func runtestpeer(t *testing.T, tp *TestPeer) {
	ln, _ := net.Listen("tcp", "127.0.0.1:5452")
	conn, _ := ln.Accept()
	defer conn.Close()
	privateKey, err := utils.LoadPrivateKeyFromFile("../../testing/private_key")
	if err != nil {
		t.Errorf("Private Key Error %v", err)
	}
	rc, err := goricochet.NegotiateVersionInbound(conn)
	if err != nil {
		t.Errorf("Negotiate Version Error: %v", err)
	}
	rc.TraceLog(true)
	err = connection.HandleInboundConnection(rc).ProcessAuthAsServer(identity.Initialize("", privateKey), PeerAuthValid)
	if err != nil {
		t.Errorf("ServerAuth Error: %v", err)
	}
	tp.RegisterChannelHandler("im.cwtch.peer", func() channels.Handler {
		peer := new(peer.CwtchPeerChannel)
		peer.Handler = tp
		return peer
	})

	go func() {
		alice := model.GenerateNewProfile("alice")
		time.Sleep(time.Second * 1)
		rc.Do(func() error {
			channel := rc.Channel("im.cwtch.peer", channels.Inbound)
			if channel != nil {
				peerchannel, ok := channel.Handler.(*peer.CwtchPeerChannel)
				if ok {
					peerchannel.SendMessage(alice.GetCwtchIdentityPacket())
				}
			}
			return nil
		})
	}()

	rc.Process(tp)
}

type TestPeer struct {
	connection.AutoConnectionHandler
	ReceivedIdentityPacket bool
	ReceivedGroupInvite    bool
}

func (tp *TestPeer) ClientIdentity(ci *protocol.CwtchIdentity) {
	tp.ReceivedIdentityPacket = true
}

func (tp *TestPeer) HandleGroupInvite(gci *protocol.GroupChatInvite) {
	tp.ReceivedGroupInvite = true
}

func TestPeerPeerConnection(t *testing.T) {
	profile := model.GenerateNewProfile("sarah")
	ppc := NewPeerPeerConnection("127.0.0.1:5452|kwke2hntvyfqm7dr", profile)
	//numcalls := 0
	tp := new(TestPeer)
	tp.Init()
	go runtestpeer(t, tp)
	state := ppc.GetState()
	if state != DISCONNECTED {
		t.Errorf("new connections should start in disconnected state")
	}
	go ppc.Run()
	time.Sleep(time.Second * 5)
	state = ppc.GetState()
	if state != AUTHENTICATED {
		t.Errorf("connection state should be authenticated(3), was instead %v", state)
	}

	if tp.ReceivedIdentityPacket == false {
		t.Errorf("should have received an identity packet")
	}

	_, invite := profile.StartGroup("aaa.onion")
	ppc.SendGroupInvite(invite)
	time.Sleep(time.Second * 3)
	if tp.ReceivedGroupInvite == false {
		t.Errorf("should have received an group invite packet")
	}

}