package congo

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"time"

	"congo.gg/pkg/platform"
)

type backend struct {
	baseURL string
	apiKey  string
	client  *http.Client
}

// Compile-time interface checks
var _ platform.Backend = (*backend)(nil)
var _ platform.SSHKeyProvider = (*backend)(nil)
var _ platform.VPCProvider = (*backend)(nil)
var _ platform.LoadBalancerProvider = (*backend)(nil)
var _ platform.TagProvider = (*backend)(nil)

// Option configures the Congo platform provider.
type Option func(*backend)

// WithBaseURL sets the congo-host service URL.
func WithBaseURL(url string) Option {
	return func(b *backend) { b.baseURL = url }
}

// WithHTTPClient sets a custom HTTP client.
func WithHTTPClient(c *http.Client) Option {
	return func(b *backend) { b.client = c }
}

// New creates a Congo platform provider that delegates to host.congo.gg.
func New(apiKey string, opts ...Option) (*platform.Platform, error) {
	if apiKey == "" {
		return nil, fmt.Errorf("api key required")
	}
	b := &backend{
		baseURL: "https://host.congo.gg",
		apiKey:  apiKey,
		client:  &http.Client{Timeout: 6 * time.Minute},
	}
	for _, opt := range opts {
		opt(b)
	}
	return &platform.Platform{Backend: b}, nil
}

// do executes an HTTP request against the congo-host API.
func (b *backend) do(method, path string, body any) (*http.Response, error) {
	var reqBody io.Reader
	if body != nil {
		data, err := json.Marshal(body)
		if err != nil {
			return nil, fmt.Errorf("marshal request: %w", err)
		}
		reqBody = bytes.NewReader(data)
	}
	req, err := http.NewRequest(method, b.baseURL+path, reqBody)
	if err != nil {
		return nil, err
	}
	req.Header.Set("Authorization", "Bearer "+b.apiKey)
	if body != nil {
		req.Header.Set("Content-Type", "application/json")
	}
	return b.client.Do(req)
}

// mapError converts an HTTP error response to a platform error.
func (b *backend) mapError(resp *http.Response) error {
	var e struct {
		Error string `json:"error"`
		Code  string `json:"code"`
	}
	json.NewDecoder(io.LimitReader(resp.Body, 1<<20)).Decode(&e)
	switch e.Code {
	case "not_found":
		return platform.ErrNotFound
	case "timeout":
		return platform.ErrTimeout
	case "unsupported_region":
		return fmt.Errorf("%w: %s", platform.ErrUnsupportedRegion, e.Error)
	case "unsupported_size":
		return fmt.Errorf("%w: %s", platform.ErrUnsupportedSize, e.Error)
	case "unsupported":
		return platform.ErrUnsupported
	default:
		return fmt.Errorf("congo host: %s", e.Error)
	}
}

// decode reads a JSON response into v, handling errors.
func (b *backend) decode(resp *http.Response, v any) error {
	defer resp.Body.Close()
	if resp.StatusCode >= 400 {
		return b.mapError(resp)
	}
	return json.NewDecoder(resp.Body).Decode(v)
}

// Backend interface

func (b *backend) CreateServer(opts platform.ServerOptions) (*platform.Server, error) {
	resp, err := b.do("POST", "/api/servers", map[string]any{
		"name":    opts.Name,
		"size":    string(opts.Size),
		"region":  string(opts.Region),
		"image":   opts.Image,
		"ssh_key": opts.SSHKey,
		"tags":    opts.Tags,
		"backups": opts.Backups,
		"vpc_id":  opts.VpcID,
	})
	if err != nil {
		return nil, err
	}
	var s struct {
		ID        string `json:"id"`
		Name      string `json:"name"`
		IP        string `json:"ip"`
		PrivateIP string `json:"private_ip"`
		Size      string `json:"size"`
		Region    string `json:"region"`
		Status    string `json:"status"`
	}
	if err := b.decode(resp, &s); err != nil {
		return nil, err
	}
	return &platform.Server{
		ID: s.ID, Name: s.Name, IP: s.IP, PrivateIP: s.PrivateIP,
		Size: s.Size, Region: s.Region, Status: s.Status,
	}, nil
}

func (b *backend) GetServer(name string) (*platform.Server, error) {
	resp, err := b.do("GET", "/api/servers/"+name, nil)
	if err != nil {
		return nil, err
	}
	var s struct {
		ID        string `json:"id"`
		Name      string `json:"name"`
		IP        string `json:"ip"`
		PrivateIP string `json:"private_ip"`
		Size      string `json:"size"`
		Region    string `json:"region"`
		Status    string `json:"status"`
	}
	if err := b.decode(resp, &s); err != nil {
		return nil, err
	}
	return &platform.Server{
		ID: s.ID, Name: s.Name, IP: s.IP, PrivateIP: s.PrivateIP,
		Size: s.Size, Region: s.Region, Status: s.Status,
	}, nil
}

func (b *backend) DeleteServer(id string) error {
	resp, err := b.do("DELETE", "/api/servers/"+id, nil)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	if resp.StatusCode >= 400 {
		return b.mapError(resp)
	}
	return nil
}

func (b *backend) CreateVolume(name string, sizeGB int, region platform.Region) (*platform.Volume, error) {
	resp, err := b.do("POST", "/api/volumes", map[string]any{
		"name":    name,
		"size_gb": sizeGB,
		"region":  string(region),
	})
	if err != nil {
		return nil, err
	}
	var v struct {
		ID     string `json:"id"`
		Name   string `json:"name"`
		Size   int    `json:"size"`
		Region string `json:"region"`
	}
	if err := b.decode(resp, &v); err != nil {
		return nil, err
	}
	return &platform.Volume{ID: v.ID, Name: v.Name, Size: v.Size, Region: v.Region}, nil
}

func (b *backend) GetVolume(name string) (*platform.Volume, error) {
	resp, err := b.do("GET", "/api/volumes/"+name, nil)
	if err != nil {
		return nil, err
	}
	var v struct {
		ID       string `json:"id"`
		Name     string `json:"name"`
		Size     int    `json:"size"`
		Region   string `json:"region"`
		ServerID string `json:"server_id"`
	}
	if err := b.decode(resp, &v); err != nil {
		return nil, err
	}
	return &platform.Volume{ID: v.ID, Name: v.Name, Size: v.Size, Region: v.Region, ServerID: v.ServerID}, nil
}

func (b *backend) AttachVolume(volumeID, serverID string) error {
	resp, err := b.do("POST", "/api/volumes/"+volumeID+"/attach", map[string]string{
		"server_id": serverID,
	})
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	if resp.StatusCode >= 400 {
		return b.mapError(resp)
	}
	return nil
}

func (b *backend) DetachVolume(volumeID string) error {
	resp, err := b.do("POST", "/api/volumes/"+volumeID+"/detach", nil)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	if resp.StatusCode >= 400 {
		return b.mapError(resp)
	}
	return nil
}

// SSHKeyProvider

func (b *backend) GetSSHKeyFingerprint(publicKey string) (string, error) {
	resp, err := b.do("POST", "/api/ssh-keys", map[string]string{
		"public_key": publicKey,
	})
	if err != nil {
		return "", err
	}
	var result struct {
		Fingerprint string `json:"fingerprint"`
	}
	if err := b.decode(resp, &result); err != nil {
		return "", err
	}
	return result.Fingerprint, nil
}

// VPCProvider

func (b *backend) CreateVPC(name, region, description string) (string, error) {
	resp, err := b.do("POST", "/api/vpcs", map[string]string{
		"name": name, "region": region, "description": description,
	})
	if err != nil {
		return "", err
	}
	var result struct {
		ID string `json:"id"`
	}
	if err := b.decode(resp, &result); err != nil {
		return "", err
	}
	return result.ID, nil
}

func (b *backend) GetVPC(name string) (string, error) {
	resp, err := b.do("GET", "/api/vpcs/"+name, nil)
	if err != nil {
		return "", err
	}
	var result struct {
		ID string `json:"id"`
	}
	if err := b.decode(resp, &result); err != nil {
		return "", err
	}
	return result.ID, nil
}

// LoadBalancerProvider

func (b *backend) CreateLoadBalancer(cfg platform.LoadBalancerConfig) (*platform.LoadBalancer, error) {
	resp, err := b.do("POST", "/api/load-balancers", map[string]any{
		"name":        cfg.Name,
		"region":      string(cfg.Region),
		"vpc_id":      cfg.VpcID,
		"server_ids":  cfg.ServerIDs,
		"tags":        cfg.Tags,
		"port":        cfg.Port,
		"target_port": cfg.TargetPort,
		"health_path": cfg.HealthPath,
	})
	if err != nil {
		return nil, err
	}
	var lb struct {
		ID     string `json:"id"`
		Name   string `json:"name"`
		IP     string `json:"ip"`
		Status string `json:"status"`
	}
	if err := b.decode(resp, &lb); err != nil {
		return nil, err
	}
	return &platform.LoadBalancer{ID: lb.ID, Name: lb.Name, IP: lb.IP, Status: lb.Status}, nil
}

func (b *backend) GetLoadBalancer(name string) (*platform.LoadBalancer, error) {
	resp, err := b.do("GET", "/api/load-balancers/"+name, nil)
	if err != nil {
		return nil, err
	}
	var lb struct {
		ID     string `json:"id"`
		Name   string `json:"name"`
		IP     string `json:"ip"`
		Status string `json:"status"`
	}
	if err := b.decode(resp, &lb); err != nil {
		return nil, err
	}
	return &platform.LoadBalancer{ID: lb.ID, Name: lb.Name, IP: lb.IP, Status: lb.Status}, nil
}

func (b *backend) DeleteLoadBalancer(id string) error {
	resp, err := b.do("DELETE", "/api/load-balancers/"+id, nil)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	if resp.StatusCode >= 400 {
		return b.mapError(resp)
	}
	return nil
}

// TagProvider

func (b *backend) TagServer(serverID string, tag string) error {
	resp, err := b.do("POST", "/api/servers/"+serverID+"/tag", map[string]string{
		"tag": tag,
	})
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	if resp.StatusCode >= 400 {
		return b.mapError(resp)
	}
	return nil
}