package remnawave

import (
	"context"
	"encoding/json"
	"net/http"
)

type Squad struct {
	UUID string
	Name string
}

func (c *Client) ListInternalSquads(ctx context.Context) ([]Squad, error) {
	return c.listSquads(ctx, "/api/internal-squads")
}

func (c *Client) ListExternalSquads(ctx context.Context) ([]Squad, error) {
	return c.listSquads(ctx, "/api/external-squads")
}

func (c *Client) listSquads(ctx context.Context, path string) ([]Squad, error) {
	resp, body, err := c.get(ctx, path)
	if err != nil {
		return nil, err
	}
	if resp.StatusCode != http.StatusOK {
		return nil, apiError(resp.StatusCode, body)
	}
	return parseSquads(body), nil
}

func parseSquads(body []byte) []Squad {
	var wrap map[string]json.RawMessage
	if json.Unmarshal(body, &wrap) != nil {
		return nil
	}
	if raw, ok := wrap["response"]; ok {
		if list := squadsFromRaw(raw); len(list) > 0 {
			return list
		}
	}
	return squadsFromRaw(body)
}

func squadsFromRaw(data []byte) []Squad {
	var arr []map[string]json.RawMessage
	if json.Unmarshal(data, &arr) == nil {
		return squadsFromMaps(arr)
	}
	var obj map[string]json.RawMessage
	if json.Unmarshal(data, &obj) != nil {
		return nil
	}
	for _, key := range []string{"internalSquads", "externalSquads", "squads"} {
		if raw, ok := obj[key]; ok {
			if list := squadsFromRaw(raw); len(list) > 0 {
				return list
			}
		}
	}
	for _, v := range obj {
		if list := squadsFromRaw(v); len(list) > 0 {
			return list
		}
	}
	return nil
}

func squadsFromMaps(items []map[string]json.RawMessage) []Squad {
	out := make([]Squad, 0, len(items))
	for _, m := range items {
		s := Squad{}
		if raw, ok := m["uuid"]; ok {
			_ = json.Unmarshal(raw, &s.UUID)
		}
		if raw, ok := m["name"]; ok {
			_ = json.Unmarshal(raw, &s.Name)
		}
		if s.UUID != "" {
			out = append(out, s)
		}
	}
	return out
}