package importgraph

import "sort"

type ResolverContract struct {
	ID        string   `json:"id"`
	Languages []string `json:"languages"`
	Status    string   `json:"status"`
}

var resolverContracts = []ResolverContract{
	{ID: "typescript-javascript", Languages: []string{"typescript", "javascript"}, Status: "partial"},
	{ID: "python", Languages: []string{"python"}, Status: "partial"},
	{ID: "go", Languages: []string{"go"}, Status: "implemented"},
	{ID: "java", Languages: []string{"java"}, Status: "partial"},
	{ID: "kotlin", Languages: []string{"kotlin"}, Status: "partial"},
	{ID: "csharp", Languages: []string{"csharp"}, Status: "partial"},
	{ID: "php", Languages: []string{"php"}, Status: "partial"},
	{ID: "rust", Languages: []string{"rust"}, Status: "partial"},
	{ID: "c-cpp", Languages: []string{"c", "cpp"}, Status: "partial"},
	{ID: "ruby", Languages: []string{"ruby"}, Status: "partial"},
}

// SupportedResolverContracts records the import-map resolver families expected
// by the graph contract. It is a contract scaffold, not a claim that every
// resolver is implemented. Swift is intentionally absent until a resolver
// contract exists for it.
func SupportedResolverContracts() []ResolverContract {
	out := make([]ResolverContract, len(resolverContracts))
	for i, contract := range resolverContracts {
		out[i] = ResolverContract{
			ID:        contract.ID,
			Languages: append([]string(nil), contract.Languages...),
			Status:    contract.Status,
		}
	}
	sort.Slice(out, func(i, j int) bool { return out[i].ID < out[j].ID })
	return out
}

func SupportedResolverContractIDs() []string {
	contracts := SupportedResolverContracts()
	out := make([]string, 0, len(contracts))
	for _, contract := range contracts {
		out = append(out, contract.ID)
	}
	sort.Strings(out)
	return out
}