package ethermineapi

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"strings"
)


// downloadJsonFromUrl downloadns []byte from body of web response of GET url
func downloadBytesUrl(url string) (jsonData []byte, err error) {
	webClient := &http.Client{}
	// Get response from url
	webResp, err := webClient.Get(url)
	if err != nil {
		return nil, err
	}
	// Close response body
	defer webResp.Body.Close()
	// Convert from Reader to []byte
	jsonData, err = io.ReadAll(webResp.Body)
	if err != nil {
		return nil, err
	}

	return jsonData, nil
}

func removeNulls(data []byte) []byte{
	// Convert []byte to string
	dataStr := fmt.Sprintf("%s", data)
	dataStr = strings.ReplaceAll(dataStr, "null", "0")

	// Covenrt string ot []byte
	return []byte(dataStr)
}

// Unmarahals JSON from specified url to v
// Usage example:
// <url> - string with web url to raw json data
// <JsonStruct> - struct type that describes json data at <url>
//
//    -- code --
//    var parseTo <JsonStruct>
//    err := UnmasrshalFromUrl(<url>, &parseTo)
//    -- code --
func UnmasrshalFromUrl(url string, v interface{}) error {
	// err := downloadJsonFromUrl(url)

	jsonData, err := downloadBytesUrl(url)
	if err != nil {
		return err
	}

	jsonData = removeNulls(jsonData)

	// LogDebug.Println(v)
	return  json.Unmarshal([]byte(jsonData), &v)
}


func MinerStats(pool, wallet string) (JsonCurrentStats, error) {
	var currentStats JsonCurrentStats

	url := fmt.Sprintf("%s/miner/%s/currentStats", pool, wallet)
	jsonData, err := downloadBytesUrl(url)
	if err != nil {
		return currentStats, err
	}

	dataExists, err := IsDataExists(jsonData)
	if err != nil {
		return currentStats, err
	}

	if !dataExists {
		return currentStats, fmt.Errorf("no data for miner %s", wallet)
	}

	return currentStats, json.Unmarshal(jsonData, &currentStats)//UnmasrshalFromUrl(url, &currentStats)
}

func Workers(pool, wallet string) (JsonWorker, error) {
	var workers JsonWorker

	url := fmt.Sprintf("%s/miner/%s/workers", pool, wallet)

	jsonData, err := downloadBytesUrl(url)
	if err != nil {
		return workers, err
	}

	dataExists, err := IsDataExists(jsonData)
	if err != nil {
		return workers, err
	}

	if !dataExists {
		return workers, fmt.Errorf("no data for workers of %s", wallet)
	}

	return workers, json.Unmarshal(jsonData, &workers)//UnmasrshalFromUrl(url, &workers)
}

func Payouts(pool, wallet string) (JsonPayouts, error) {
    var payouts JsonPayouts

	url := fmt.Sprintf("%s/miner/%s/payouts", pool, wallet)

	jsonData, err := downloadBytesUrl(url)
	if err != nil {
		return payouts, fmt.Errorf("couldn't get payouts from %s\n%v", url, err)
	}

	// Not needed for payouts
	// dataExists, err := IsDataExists(url)
	// if err != nil {
	// 	return payouts, err
	// }
	//
	// if !dataExists {
	// 	return workers, fmt.Errorf("no data for workers of %s", wallet)
	// }

	err = json.Unmarshal(jsonData, &payouts)
	if err != nil {
		return payouts, fmt.Errorf("couldn't parse payouts from %s\n%v", url, err)
	}

	return payouts, nil
}

// IsDataExists checks if Data part of json is not string
// TODO Redo this using dynamic Json unmarshaling
func IsDataExists(data [] byte) (bool, error) {

	var base baseResponce
	err := json.Unmarshal(data, &base)
	if err != nil {
		return false, fmt.Errorf("couldn't get base response from %s", err.Error())
	}

	if string(base.Data) == "\"NO DATA\"" {
		return false, nil
	}

	return true, nil
}