package main

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

func UnmasrshalFromUrl(url string, v interface{}) error {
	// Usage:
	// <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 --

	webClient := &http.Client{}
	// Get response from url
	webResp, err := webClient.Get(url)
	if err != nil {
		return err
	}
	// Close response body
	defer webResp.Body.Close()
	// Convert from Reader to []byte
	jsonData, err := io.ReadAll(webResp.Body)
	if err != nil {
		return err
	}
	// Convert []byte to string
	jsonDataStr := fmt.Sprintf("%s", jsonData)
	jsonDataStr = strings.ReplaceAll(jsonDataStr, "null", "0")
	// Covenrt string ot []byte
	jsonData = []byte(jsonDataStr)

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


func MinerStats(url string) (JsonCurrentStats, error) {
	var currentStats JsonCurrentStats

	urlToStats := url + "/currentStats"
	dataExists, err := IsDataExists(urlToStats)
	if err != nil {
		return currentStats, err
	}

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

	return currentStats, UnmasrshalFromUrl(urlToStats, &currentStats)
}

func IsDataExists(url string) (bool, error) {
	var interfaceJson interface{}
	
	err := UnmasrshalFromUrl(url, &interfaceJson)
	if err != nil {
		return false, err
	}

	switch interfaceJson.(map[string]interface{})["data"].(type) {
		case string: 
			if interfaceJson.(map[string]interface{})["data"].(string) == "NO DATA" {
				return false, nil
			}
			return false, fmt.Errorf("unexpected string value at interface %v", interfaceJson.(map[string]interface{})["data"].(string)) 
			break

		case map[string]interface {}:
			return true, nil
			break

		default:
			return false, fmt.Errorf("unexpected type of Data at interface - %T", interfaceJson.(map[string]interface{})["data"])
			break
	}

	return false, nil
}