package testing

import (
	"cwtch.im/cwtch/model"
	"cwtch.im/cwtch/peer"
	"cwtch.im/cwtch/protocol"
	cwtchserver "cwtch.im/cwtch/server"
	"fmt"
	"github.com/golang/protobuf/proto"
	"github.com/s-rah/go-ricochet"
	"github.com/s-rah/go-ricochet/utils"
	"io/ioutil"
	"log"
	"os"
	"testing"
	"time"
)

const (
	keyfile = "./private_key"
)

var (
	aliceLines = []string{"Hello", "My name is Alice", "bye"}
	bobLines   = []string{"Hi", "My name is Bob.", "toodles", "hello?"}
)

func checkAndGenPrivateKey(privateKeyFile string) (generated bool) {
	if _, err := os.Stat(privateKeyFile); os.IsNotExist(err) {
		fmt.Println("generating new private key...")
		pk, err := utils.GeneratePrivateKey()
		if err != nil {
			log.Fatalf("error generating new private key: %v\n", err)
		}
		err = ioutil.WriteFile(privateKeyFile, []byte(utils.PrivateKeyToString(pk)), 0400)
		if err != nil {
			log.Fatalf("error writing new private key to file %s: %v\n", privateKeyFile, err)
		}
		return true
	}
	return false
}

func printAndVerifyTimeline(t *testing.T, timeline []model.Message) error {
	for _, message := range timeline {
		fmt.Printf("%v %v> %s [%t]\n", message.Timestamp, message.PeerID, message.Message, message.Verified)
		if !message.Verified {
			t.Errorf("Message '%s' from '%s' not verified!", message.Message, message.PeerID)
		}
	}
	return nil
}

func serverCheck(serverAddr string) bool {
	rc, err := goricochet.Open(serverAddr)
	if err == nil {
		rc.Conn.Close()
		return true
	}
	return false
}

func TestCwtchPeerIntegration(t *testing.T) {
	// Hide logging "noise"
	log.SetOutput(ioutil.Discard)

	generatedKey := checkAndGenPrivateKey(keyfile)

	serverKey, err := utils.LoadPrivateKeyFromFile(keyfile)
	if err != nil {
		t.Errorf("Could not load server's key from %v", keyfile)
	}
	serverAddr, _ := utils.GetOnionAddress(serverKey)

	serverOnline := false
	if !generatedKey {
		fmt.Printf("Checking if test server %v is online...\n", serverAddr)
		serverOnline = serverCheck(serverAddr)
	}

	if !serverOnline {
		// launch app
		server := new(cwtchserver.Server)
		fmt.Printf("No server found\nStarting cwtch server...\n")
		go server.Run(keyfile)

		// let tor get established
		fmt.Printf("Establishing Tor hidden service: %v...\n", serverAddr)
		time.Sleep(time.Second * 120)
	} else {
		fmt.Printf("Found existing cwtch server %v, using for tests...\n", serverAddr)
	}

	// launch alice
	fmt.Println("Creating Alice...")
	alice := peer.NewCwtchPeer("Alice")
	alice.Profile.AddContact(alice.Profile.Onion, &alice.Profile.PublicProfile)
	fmt.Println("Alice created:", alice.Profile.Onion)

	fmt.Println("Starting group on ", serverAddr, "...")
	groupId, invite, err := alice.Profile.StartGroup(serverAddr)
	fmt.Printf("Started group: %v!\n", groupId)
	if err != nil {
		t.Errorf("Failed to start group: %v", err)
		return
	}

	gci := &protocol.CwtchPeerPacket{}
	proto.Unmarshal(invite, gci)

	fmt.Println("Alice joining server/group...")
	alice.JoinServer(serverAddr)

	// launch bob
	fmt.Println("Creating Bob...")
	bob := peer.NewCwtchPeer("Bob")
	bob.Profile.AddContact(bob.Profile.Onion, &bob.Profile.PublicProfile)
	fmt.Println("Bob created:", bob.Profile.Onion)

	// Associate peer alice & bob as peers
	fmt.Println("Peering Alice and Bob...")
	alice.Profile.AddContact(bob.Profile.Onion, &bob.Profile.PublicProfile)
	bob.Profile.AddContact(alice.Profile.Onion, &alice.Profile.PublicProfile)

	// TODO: have alice actually send the invite
	fmt.Printf("Bob processing invite to group %v\n", gci.GetGroupChatInvite().GroupName)
	bob.Profile.ProcessInvite(gci.GetGroupChatInvite(), alice.Profile.Onion)

	fmt.Println("Bob joining server/group...")
	bob.JoinServer(serverAddr)

	// Wait for them to join the server
	time.Sleep(time.Second * 60)

	fmt.Println("Starting conversation in group...")
	// Conversation
	fmt.Println("Alice> ", aliceLines[0])
	err = alice.SendMessageToGroup(groupId, aliceLines[0])
	if err != nil {
		t.Errorf("Alice failed to send a message to the group: %v", err)
	}
	time.Sleep(time.Second * 10)

	fmt.Println("Bob> ", bobLines[0])
	err = bob.SendMessageToGroup(groupId, bobLines[0])
	if err != nil {
		t.Errorf("Bob failed to send a message to the group: %v", err)
	}
	time.Sleep(time.Second * 10)

	// "instant" - could be either order?
	fmt.Println("Alice> ", aliceLines[1])
	alice.SendMessageToGroup(groupId, aliceLines[1])
	fmt.Println("Bob> ", bobLines[1])
	bob.SendMessageToGroup(groupId, bobLines[1])
	time.Sleep(time.Second * 10)

	fmt.Println("Alice> ", aliceLines[2])
	alice.SendMessageToGroup(groupId, aliceLines[2])
	// Todo: Alice disconnects
	time.Sleep(time.Second * 10)

	fmt.Println("Bob> ", bobLines[2])
	bob.SendMessageToGroup(groupId, bobLines[2])
	time.Sleep(time.Second * 10)

	// Todo: Alice reconects, gets missed messages (from bob)

	// Verify

	// final syncing time...
	time.Sleep(time.Second * 10)

	alicesGroup := alice.Profile.GetGroupByGroupID(groupId)
	fmt.Printf("alice Groups:\n")
	for k := range alice.Profile.Groups {
		fmt.Println(" " + k)
	}
	if alicesGroup == nil {
		t.Error("aliceGroup == nil")
		return
	}

	fmt.Printf("Alice TimeLine:\n")
	printAndVerifyTimeline(t, alicesGroup.GetTimeline())

	bobsGroup := bob.Profile.GetGroupByGroupID(groupId)
	fmt.Printf("bob Groups:\n")
	for k := range bob.Profile.Groups {
		fmt.Println(" " + k)
	}
	if bobsGroup == nil {
		t.Error("bobGroup == nil")
		return
	}
	fmt.Printf("Bob TimeLine:\n")
	printAndVerifyTimeline(t, bobsGroup.GetTimeline())

	if len(alicesGroup.Timeline.Messages) != 6 {
		t.Errorf("Alice's timeline does not have all messages")
		return
	}

	// check message 0,1 and 4,5 for content (2,3 could be out of order)
	aliceGroupTimeline := alicesGroup.GetTimeline()
	if aliceGroupTimeline[0].Message != aliceLines[0] || aliceGroupTimeline[1].Message != bobLines[0] ||
		aliceGroupTimeline[4].Message != aliceLines[2] || aliceGroupTimeline[5].Message != bobLines[2] {
		t.Errorf("Some of the messages did not have the expected content!")
	}

	// Todo: shutdown users and server
}