package output

import (
	"fmt"
	"slices"
	"sort"
	"strings"

	"github.com/hashicorp/go-version"

	"codeberg.org/june64/mrvc/roominfotree"
)

func compareVersionStrings(a, b string) int {
	// Try to parse a and b as versions.
	// Use only the first part of the version string as sometimes there are suffixes after a space, like " (<commit>)", which then can't be parsed.
	aStart := strings.Split(a, " ")[0]
	bStart := strings.Split(b, " ")[0]
	aVersion, aErr := version.NewVersion(aStart)
	bVersion, bErr := version.NewVersion(bStart)
	// An input, which can't be parsed as a version, should be interpreted as being smaller than an input, which can be parsed as a version.
	switch {
	case aErr != nil && bErr == nil:
		return -1
	case aErr == nil && bErr != nil:
		return 1
	case aErr != nil && bErr != nil:
		return strings.Compare(a, b)
	}

	if cmpResult := aVersion.Compare(bVersion); cmpResult != 0 {
		return cmpResult
	} else {
		// When the versions are equal, look at the potential suffixes in the version string.
		aEnd := strings.TrimPrefix(a, aStart)
		bEnd := strings.TrimPrefix(b, bStart)

		return strings.Compare(aEnd, bEnd)
	}
}

func Print(roomInfoTree roominfotree.RoomInfoTree, outputHomeserverMemberCount bool) {
	for roomID, roomInfo := range roomInfoTree {
		fmt.Println("Room:")
		fmt.Printf("  %s -> %d\n", roomID, roomInfo.MemberCount)
		givenAliases := roomInfo.GivenAliases
		if len(givenAliases) > 0 {
			fmt.Println("Given Aliases:")
			for _, alias := range givenAliases {
				fmt.Printf("  %s\n", alias)
			}
		}
		aliases := roomInfo.Aliases
		if len(aliases) > 0 {
			fmt.Println("Aliases:")
			for _, alias := range aliases {
				fmt.Printf("  %s\n", alias)
			}
		}

		fmt.Println("Version Support:")

		maxRoomVersionKeys := make([]string, 0, len(roomInfo.MaxRoomVersions))
		for key := range roomInfo.MaxRoomVersions {
			maxRoomVersionKeys = append(maxRoomVersionKeys, key)
		}
		slices.SortFunc(maxRoomVersionKeys, compareVersionStrings)
		for _, maxRoomVersionKey := range maxRoomVersionKeys {
			maxRoomVersionInfo := roomInfo.MaxRoomVersions[maxRoomVersionKey]

			fmt.Printf("  %s -> %d\n", maxRoomVersionKey, maxRoomVersionInfo.MemberCount)

			serverKeys := make([]string, 0, len(maxRoomVersionInfo.Servers))
			for key := range maxRoomVersionInfo.Servers {
				serverKeys = append(serverKeys, key)
			}
			sort.Strings(serverKeys)
			for _, serverKey := range serverKeys {
				serverInfo := maxRoomVersionInfo.Servers[serverKey]

				fmt.Printf("    %s -> %d\n", serverKey, serverInfo.MemberCount)

				versionKeys := make([]string, 0, len(serverInfo.Versions))
				for key := range serverInfo.Versions {
					versionKeys = append(versionKeys, key)
				}
				slices.SortFunc(versionKeys, compareVersionStrings)
				for _, versionKey := range versionKeys {
					versionInfo := serverInfo.Versions[versionKey]

					fmt.Printf("      %s -> %d\n", versionKey, versionInfo.MemberCount)

					if outputHomeserverMemberCount {
						homeserverKeys := make([]string, 0, len(versionInfo.Homeservers))
						for key := range versionInfo.Homeservers {
							homeserverKeys = append(homeserverKeys, key)
						}
						sort.Strings(homeserverKeys)
						for _, homeserverKey := range homeserverKeys {
							homeserverInfo := versionInfo.Homeservers[homeserverKey]

							fmt.Printf("        %s -> %d\n", homeserverKey, homeserverInfo.MemberCount)
						}
					}
				}
			}
		}

		fmt.Println()
	}
}