package mesh

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"time"
)

type Client struct {
	BaseURL    string
	HTTPClient *http.Client
}

func NewClient(baseURL string) Client {
	return Client{
		BaseURL: baseURL,
		HTTPClient: &http.Client{
			Timeout: 5 * time.Second,
		},
	}
}

func (c Client) SendHealth(ctx context.Context, message HealthMessage) (HealthAck, error) {
	payload, err := json.Marshal(message)
	if err != nil {
		return HealthAck{}, err
	}
	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.BaseURL+"/mesh/v1/health", bytes.NewReader(payload))
	if err != nil {
		return HealthAck{}, err
	}
	req.Header.Set("Content-Type", "application/json")
	httpClient := c.HTTPClient
	if httpClient == nil {
		httpClient = http.DefaultClient
	}
	resp, err := httpClient.Do(req)
	if err != nil {
		return HealthAck{}, err
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return HealthAck{}, fmt.Errorf("mesh health rejected with status %d", resp.StatusCode)
	}
	var ack HealthAck
	if err := json.NewDecoder(resp.Body).Decode(&ack); err != nil {
		return HealthAck{}, err
	}
	return ack, nil
}

func (c Client) SendSynthetic(ctx context.Context, envelope SyntheticEnvelope) (SyntheticEnvelope, error) {
	payload, err := json.Marshal(envelope)
	if err != nil {
		return SyntheticEnvelope{}, err
	}
	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.BaseURL+"/mesh/v1/synthetic/probe", bytes.NewReader(payload))
	if err != nil {
		return SyntheticEnvelope{}, err
	}
	req.Header.Set("Content-Type", "application/json")
	httpClient := c.HTTPClient
	if httpClient == nil {
		httpClient = http.DefaultClient
	}
	resp, err := httpClient.Do(req)
	if err != nil {
		return SyntheticEnvelope{}, err
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return SyntheticEnvelope{}, fmt.Errorf("mesh synthetic probe rejected with status %d", resp.StatusCode)
	}
	var ack SyntheticEnvelope
	if err := json.NewDecoder(resp.Body).Decode(&ack); err != nil {
		return SyntheticEnvelope{}, err
	}
	return ack, nil
}

func (c Client) SendProduction(ctx context.Context, envelope ProductionEnvelope) (ProductionForwardResult, error) {
	payload, err := json.Marshal(envelope)
	if err != nil {
		return ProductionForwardResult{}, err
	}
	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.BaseURL+"/mesh/v1/forward", bytes.NewReader(payload))
	if err != nil {
		return ProductionForwardResult{}, err
	}
	req.Header.Set("Content-Type", "application/json")
	httpClient := c.HTTPClient
	if httpClient == nil {
		httpClient = http.DefaultClient
	}
	resp, err := httpClient.Do(req)
	if err != nil {
		return ProductionForwardResult{}, err
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return ProductionForwardResult{}, fmt.Errorf("mesh production forward rejected with status %d", resp.StatusCode)
	}
	var result ProductionForwardResult
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return ProductionForwardResult{}, err
	}
	return result, nil
}