package testclient

import (
	"bufio"
	"flag"
	"fmt"
	"io/ioutil"
	"math/rand"
	"net/http"
	"os"
	"time"
)

var chatAddress = "localhost:8000"
var loginAddress = "localhost:8001"
var rate = 1000
var wordPerMessage = 3
var refresh = 240
var listen bool
var autoSend bool
var stdinSend bool
var LoadMessages bool
var debug bool
var serverName string
var test bool

var wordsSource = "https://gist.githubusercontent.com/deekayen/4148741/raw/98d35708fa344717d8eee15d11987de6c8e26d7d/1-1000.txt"
var wordsList []string
var rng *rand.Rand

var Username string
var token string
var session string

var Done chan (struct{})
var Line chan string

func debugPrint(args ...any) {
	if debug {
		fmt.Print("DEBUG: ")
		fmt.Println(args...)
		fmt.Println() // spacer
	}
}

func Initialise() error {
	parseArgs()

	if test {
		listen, autoSend, LoadMessages, debug = true, true, true, true
	}

	if list, err := buildWordsList(wordsSource); err != nil {
		return err
	} else {
		wordsList = list
	}

	rng = rand.New(rand.NewSource(time.Now().Unix()))
	generateUsername()

	if stdinSend {
		go sendFromStdin()
	}

	go manageToken()
	return nil
}

func generateUsername() {
	Username = wordsList[rng.Intn(len(wordsList))] + "_" + wordsList[rng.Intn(len(wordsList))]
}

func parseArgs() {
	flag.StringVar(&chatAddress, "chataddr", chatAddress, "address for chat server")
	flag.StringVar(&loginAddress, "loginaddr", loginAddress, "address for login server")
	flag.StringVar(&serverName, "server", serverName, "server name (blank for main)")
	flag.IntVar(&rate, "rate", rate, "time in ms between messages")
	flag.IntVar(&wordPerMessage, "wpm", wordPerMessage, "words per message")
	flag.BoolVar(&listen, "listen", listen, "listen and echo every message received")
	flag.BoolVar(&autoSend, "autosend", autoSend, "auto generate and send messages of length and rate specified")
	flag.BoolVar(&LoadMessages, "load", LoadMessages, "load most recent messages when connecting to chat")
	flag.BoolVar(&debug, "debug", debug, "print additional debug messages e.g. http responses, auth token")
	flag.IntVar(&refresh, "refresh", refresh, "auth token refresh rate in seconds")
	flag.BoolVar(&stdinSend, "send", stdinSend, "send messages from CLI")
	flag.BoolVar(&test, "test", test, "test all functionality (implies -listen, -autosend, -load, -debug)")

	flag.Parse()
}

func createMessage() (message string) {
	for i := 0; i < wordPerMessage; i++ {
		message += wordsList[rng.Intn(len(wordsList))] + " "
	}
	return
}

func buildWordsList(url string) (wordsList []string, err error) {
	res, err := http.Get(url)
	if err != nil {
		fmt.Fprintln(os.Stderr, err.Error())
		return
	}
	wordsList = make([]string, 0)
	body, err := ioutil.ReadAll(res.Body)
	if err != nil {
		fmt.Fprintln(os.Stderr, "error reading response body:", err)
	}

	var word []byte
	for _, char := range body {
		if char == '\r' {
			continue
		}
		if char == '\n' {
			wordsList = append(wordsList, string(word))
			word = make([]byte, 0)
		} else {
			word = append(word, char)
		}
	}
	return
}

func sendFromStdin() {
	defer func() {
		fmt.Println("stopped reading from stdin")
	}()

	Line = make(chan string)

	reader := bufio.NewReader(os.Stdin)

	for {
		l, _, err := reader.ReadLine()
		if err != nil {
			fmt.Println(err.Error())
			return
		}
		Line <- string(l)
	}
}

func manageToken() {
	ticker := time.NewTicker(time.Second * time.Duration(refresh))

	for {
		<-ticker.C
		refreshToken()
	}
}