package testclient

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"net/http/cookiejar"
	"net/url"
	"os"
	"time"

	"github.com/gorilla/websocket"
)

type TokenObj struct {
	Token string `json:"session"`
}
type SessionObj struct {
	Session string `json:"session"`
}

var client *http.Client
var conn *websocket.Conn

func InitHttpClient() (err error) {
	jar, err := cookiejar.New(nil)
	if err != nil {
		fmt.Fprintln(os.Stderr, "error initialising cookie jar", err.Error())
		return err
	}

	client = &http.Client{
		Jar: jar,
	}
	return
}

func Register() error {
	postBody := []byte(`{"username":"` + Username + `","password":"Password1!"}`)
	req, err := http.NewRequest("POST", "http://"+loginAddress+"/register", bytes.NewBuffer(postBody))
	if err != nil {
		fmt.Fprintln(os.Stderr, err.Error())
		return err
	}
	res, err := client.Do(req)
	if err != nil {
		fmt.Fprintln(os.Stderr, "could not reach login server", err.Error())
		os.Exit(1)
	}
	if res.StatusCode != http.StatusCreated {
		fmt.Fprintln(os.Stderr, "Status code", res.StatusCode, "received")
		os.Exit(1)
	}

	body, err := ioutil.ReadAll(res.Body)
	if err != nil {
		fmt.Fprintln(os.Stderr, "error reading register body:", err)
		os.Exit(1)
	}

	debugPrint("sent ", string(postBody), "received", res.StatusCode, "from", req.URL, "with response body", string(body))

	type TokenObj struct {
		Token string `json:"token"`
	}
	var tokenObj TokenObj

	if err := json.Unmarshal(body, &tokenObj); err != nil {
		fmt.Fprintln(os.Stderr, "error unmarshalling token:", err.Error())
		return err
	}

	token = tokenObj.Token

	debugPrint("initial token set to", token)

	return nil
}

func WsConnect() {
    u := url.URL{Scheme: "ws", Host: chatAddress, Path: "/connect", RawQuery: "name=" + serverName}
	var err error

    header := http.Header{}
    header.Set("Token", token)

    conn, _, err = websocket.DefaultDialer.Dial(u.String(), header)
	if err != nil {
		fmt.Fprintln(os.Stderr, "error connecting to ws: ", err.Error())
		return
	}
	Done = make(chan struct{})

	debugPrint("connected to websocket server", serverName, "(blank for root) at", u.String())

	go func() {
		defer conn.Close()
		for {
			_, mess, err := conn.ReadMessage()
			if err != nil {
				fmt.Println(err)
				Done <- struct{}{}
				return
			}
			if listen {
				fmt.Println(string(mess))
			}
		}
	}()

	if autoSend {
		go func() {
			t := time.NewTicker(time.Millisecond * time.Duration(rate))
			for {
				<-t.C
				SendMessage(createMessage())
			}
		}()
	}
}

func SendMessage(message string) {
	mess := []byte(`{"text":"` + message + `","user":"` + token + `"}`)

	req, err := http.NewRequest("POST", "http://"+chatAddress+"/send?name="+serverName, bytes.NewBuffer(mess))
	if err != nil {
		fmt.Fprintln(os.Stderr, "creating post request error:", err.Error())
		os.Exit(1)
	}
	req.Header.Set("Token", token)
	res, err := client.Do(req)
	if err != nil {
		fmt.Fprintln(os.Stderr, "sending post request error:", err.Error())
	}
	if res.StatusCode != http.StatusOK {
		fmt.Fprintln(os.Stderr, "received", res.StatusCode, "when sending message")
	}

	debugPrint("sent", message, "received", res.StatusCode)
}

func LoadDefaultMessages() {
	req, err := http.NewRequest("GET", "http://"+chatAddress+"/messages?name="+serverName, nil)
	if err != nil {
		fmt.Fprintln(os.Stderr, "creating get request error:", err.Error())
		os.Exit(1)
	}
	req.Header.Set("Token", token)
	res, err := client.Do(req)
	if err != nil {
		fmt.Fprintln(os.Stderr, "sending get request error:", err.Error())
		return
	}
	if res.StatusCode != http.StatusOK {
		fmt.Fprintln(os.Stderr, "received", res.StatusCode, "when loading message")
	}

	body, err := ioutil.ReadAll(res.Body)
	if err != nil {
		fmt.Fprintln(os.Stderr, "error reading response body:", err)
	}

	debugPrint("load messages: status", res.StatusCode, "body:", string(body))
}

func refreshToken() {
	req, err := http.NewRequest("GET", "http://"+loginAddress+"/auth", nil)
	if err != nil {
		fmt.Fprintln(os.Stderr, "creating get request error:", err.Error())
		os.Exit(1)
	}
	res, err := client.Do(req)
	if err != nil {
		fmt.Fprintln(os.Stderr, "could not reach login server", err.Error())
		os.Exit(1)
	}
	body, err := ioutil.ReadAll(res.Body)
	if err != nil {
		fmt.Fprintln(os.Stderr, "error reading auth response body:", err)
	}

	if res.StatusCode != http.StatusOK {
		fmt.Fprintln(os.Stderr, "/auth received status code", res.StatusCode, "with body", string(body))
	}

	type TokenObj struct {
		Token string `json:"token"`
	}
	var tokenObj TokenObj

	if err := json.Unmarshal(body, &tokenObj); err != nil {
		fmt.Fprintln(os.Stderr, "error unmarshalling token:", err.Error())
		return
	}

	token = tokenObj.Token
	debugPrint("refreshing token to", token)
}