package actions

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"strings"
	"syscall"
	"time"

	"git.t-juice.club/torjus/gpaste/api"
	"git.t-juice.club/torjus/gpaste/client"
	"git.t-juice.club/torjus/gpaste/files"
	"github.com/urfave/cli/v2"
	"golang.org/x/term"
)

func ActionUpload(c *cli.Context) error {
	clnt := client.Client{
		BaseURL: c.String("url"),
	}
	for _, arg := range c.Args().Slice() {
		f, err := os.Open(arg)
		if err != nil {
			return err
		}
		defer f.Close()
		file := &files.File{
			OriginalFilename: arg,
			Body:             f,
		}
		resp, err := clnt.Upload(c.Context, file)
		if err != nil {
			errmsg := fmt.Sprintf("Error uploading file: %s", err)
			return cli.Exit(errmsg, 1)
		}
		fmt.Printf("Uploaded file %s - %s", file.OriginalFilename, resp[0].URL)
	}
	return nil
}

func ActionLogin(c *cli.Context) error {
	username := c.Args().First()
	if username == "" {
		return cli.Exit("USERNAME not supplied.", 1)
	}
	password, err := readPassword()
	if err != nil {
		return fmt.Errorf("error reading password: %w", err)
	}

	url := fmt.Sprintf("%s/api/login", c.String("url"))
	client := &http.Client{}
	// TODO: Change timeout
	ctx, cancel := context.WithTimeout(c.Context, 10*time.Second)
	defer cancel()

	body := new(bytes.Buffer)
	requestData := struct {
		Username string `json:"username"`
		Password string `json:"password"`
	}{
		Username: username,
		Password: password,
	}
	encoder := json.NewEncoder(body)
	if err := encoder.Encode(&requestData); err != nil {
		return fmt.Errorf("error encoding response: %w", err)
	}
	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, body)
	if err != nil {
		return fmt.Errorf("error creating request: %w", err)
	}

	resp, err := client.Do(req)
	if err != nil {
		return fmt.Errorf("unable to perform request: %s", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return cli.Exit("got non-ok response from server", 0)
	}

	responseData := struct {
		Token string `json:"token"`
	}{}

	decoder := json.NewDecoder(resp.Body)
	if err := decoder.Decode(&responseData); err != nil {
		return fmt.Errorf("unable to parse response: %s", err)
	}

	fmt.Printf("Token: %s", responseData.Token)

	return nil
}

func ActionUserCreate(c *cli.Context) error {
	// TODO: Needs to supply auth token to actually work
	username := c.Args().First()
	if username == "" {
		return cli.Exit("USERNAME not supplied.", 1)
	}
	password, err := readPassword()
	if err != nil {
		return fmt.Errorf("error reading password: %w", err)
	}

	url := fmt.Sprintf("%s/api/user", c.String("url"))
	client := &http.Client{}
	// TODO: Change timeout
	ctx, cancel := context.WithTimeout(c.Context, 10*time.Second)
	defer cancel()

	body := new(bytes.Buffer)
	requestData := &api.RequestAPIUserCreate{
		Username: username,
		Password: password,
	}
	encoder := json.NewEncoder(body)
	if err := encoder.Encode(requestData); err != nil {
		return fmt.Errorf("error encoding response: %w", err)
	}
	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, body)
	if err != nil {
		return fmt.Errorf("error creating request: %w", err)
	}

	resp, err := client.Do(req)
	if err != nil {
		return fmt.Errorf("unable to perform request: %s", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusAccepted {
		return cli.Exit("got non-ok response from server", 0)
	}

	fmt.Printf("Created user %s\n", username)

	return nil
}

func readPassword() (string, error) {
	fmt.Print("Enter Password: ")
	bytePassword, err := term.ReadPassword(int(syscall.Stdin))
	if err != nil {
		return "", err
	}

	password := string(bytePassword)
	return strings.TrimSpace(password), nil
}