package auth

import (
	"bytes"
	"donat-widget/internal/model"
	"donat-widget/internal/model/api"
	"encoding/json"
	"errors"
	"github.com/labstack/echo/v4"
	"io"
	"log/slog"
	"net/http"
	"strconv"
)

func New(host, port string) *ClientAuth {
	return &ClientAuth{
		client:  &http.Client{},
		baseURL: "http://" + host + ":" + port + "/api/auth",
	}
}

type ClientAuth struct {
	client  *http.Client
	baseURL string
}

func (c *ClientAuth) CheckToken(
	request echo.Context,
) (api.CheckTokenResponse, error) {
	_accessToken, err := request.Cookie("Access-Token")
	if err != nil {
		slog.Error("request.Cookie: " + err.Error())
		return api.CheckTokenResponse{}, err
	}
	accessToken := _accessToken.Value

	req, err := http.NewRequest("GET", c.baseURL+"/token/check", nil)
	if err != nil {
		slog.Error("http.NewRequest: " + err.Error())
		return api.CheckTokenResponse{}, err
	}
	req.AddCookie(&http.Cookie{Name: "Access-Token", Value: accessToken})
	resp, err := c.client.Do(req)
	if err != nil {
		slog.Error("client.Do: " + err.Error())
		return api.CheckTokenResponse{}, err
	}
	if resp.StatusCode != http.StatusOK {
		return api.CheckTokenResponse{}, errors.New("get failed: " + resp.Status)
	}

	response, err := io.ReadAll(resp.Body)
	if err != nil {
		slog.Error("io.ReadAll: " + err.Error())
		return api.CheckTokenResponse{}, err
	}

	var checkTokenResponse api.CheckTokenResponse
	err = json.Unmarshal(response, &checkTokenResponse)
	if err != nil {
		slog.Error("json.Unmarshal: " + err.Error())
		return api.CheckTokenResponse{}, err
	}
	return checkTokenResponse, nil
}

func (c *ClientAuth) VerifyTwoFa(
	twoFaCode string,
	streamerID model.StreamerID,
) (bool, error) {
	_accountID := strconv.Itoa(int(streamerID))
	path := c.baseURL + "/twoFa/verify" + "/" + _accountID + "/" + string(twoFaCode)
	req, err := http.NewRequest("GET", path, nil)
	if err != nil {
		slog.Error("http.NewRequest: " + err.Error())
		return false, err
	}

	resp, err := c.client.Do(req)
	if err != nil {
		slog.Error("client.Do: " + err.Error())
		return false, err
	}
	if resp.StatusCode != http.StatusOK {
		return false, errors.New("get failed: " + resp.Status)
	}
	response, err := io.ReadAll(resp.Body)
	if err != nil {
		slog.Error("io.ReadAll: " + err.Error())
		return false, err
	}
	var verifyTokenResponse api.VerifyTokenResponse
	err = json.Unmarshal(response, &verifyTokenResponse)
	if err != nil {
		slog.Error("json.Unmarshal: " + err.Error())
		return false, err
	}
	return verifyTokenResponse.Verified, nil
}

func (c *ClientAuth) post(path string, body map[string]any) ([]byte, error) {
	bytesBody, _ := json.Marshal(body)

	resp, err := c.client.Post(c.baseURL+path, "application/json", bytes.NewReader(bytesBody))
	if err != nil {
		slog.Error("c.client.Post: " + err.Error())
		return nil, err

	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		return nil, errors.New("tinkoff: post failed: " + resp.Status)
	}

	response, err := io.ReadAll(resp.Body)
	if err != nil {
		slog.Error("io.ReadAll: " + err.Error())
		return nil, err
	}

	return response, nil
}