package v2

import (
	"fmt"

	v1 "edge-infra.dev/pkg/sds/display/k8s/apis/v1"
)

// Converts a V1 DisplayConfig to V2.
//
// As the identifier for displays moves from MPID to DisplayPort, the conversion
// requires the current display configuration read from the node. Using this
// we can tell which port displays identified by MPID are connected to.
//
// For displays which have been specified in the V1 display config, but are not
// connected at the time of the conversion, their DisplayPort will be marked as
// disconnected. A map of disconnected DisplayPorts to MPIDs will also be
// returned, so they can later be converted later on if the display is reconnected.
func DisplayConfigFromV1(src *v1.DisplayConfig, displayConfig *DisplayConfig) (result *DisplayConfig, disconnectedIDs map[DisplayPort]MPID) {
	if src == nil {
		return nil, nil
	}

	ids, disconnectedIDs := convertMPIDs(src, displayConfig)

	return &DisplayConfig{
		Displays: convertDisplaysFromV1(src, ids),
		Layout:   convertLayoutFromV1(src, ids),
		DPMS:     convertDPMSFromV1(src),
	}, disconnectedIDs
}

func convertMPIDs(src *v1.DisplayConfig, displayConfig *DisplayConfig) (ids map[v1.MPID]DisplayPort, disconnectedIDs map[DisplayPort]MPID) {
	// keep track of disconnected displays so we can retain them after conversion
	disconnectedCount := 0

	ids = map[v1.MPID]DisplayPort{}
	disconnectedIDs = map[DisplayPort]MPID{}

	for _, mpid := range src.MPIDs() {
		if display := displayConfig.Displays.FindByMPID(MPID(mpid)); display != nil {
			ids[mpid] = display.DisplayPort
		} else {
			disconnectedCount++
			port := fmt.Sprintf("%s-%d", DisconnectedPort, disconnectedCount)
			dp := NewDisplayPort(UnknownCard, port)
			ids[mpid] = dp
			disconnectedIDs[dp] = MPID(mpid)
		}
	}

	return ids, disconnectedIDs
}

func convertDisplaysFromV1(src *v1.DisplayConfig, ids map[v1.MPID]DisplayPort) Displays {
	if src.Displays == nil {
		return nil
	}

	displays := Displays{}
	for _, mpid := range src.Displays.MPIDs() {
		display := src.Displays[mpid]
		displays.UpdateDisplay(convertDisplayFromV1(display, ids[mpid]))
	}

	return displays
}

func convertDisplayFromV1(src v1.Display, dp DisplayPort) Display {
	return Display{
		DisplayPort:         dp,
		Primary:             (*Primary)(src.Primary),
		Orientation:         (*Orientation)(src.Orientation),
		Resolution:          (*Resolution)(src.Resolution),
		InputDeviceMappings: convertInputDeviceMappingsFromV1(src.InputDeviceMappings),
	}
}

func convertInputDeviceMappingsFromV1(src []v1.InputDeviceName) []InputDeviceName {
	var inputDeviceMappings []InputDeviceName
	for _, inputDeviceName := range src {
		inputDeviceMappings = append(inputDeviceMappings, InputDeviceName(inputDeviceName))
	}
	return inputDeviceMappings
}

func convertLayoutFromV1(src *v1.DisplayConfig, ids map[v1.MPID]DisplayPort) Layout {
	if src.Layout == nil {
		return nil
	}

	layout := Layout{}
	for _, mpid := range src.Layout {
		layout = append(layout, ids[mpid])
	}

	return layout
}

func convertDPMSFromV1(src *v1.DisplayConfig) *DPMS {
	if src.DPMS == nil {
		return nil
	}

	return &DPMS{
		Enabled:     src.DPMS.Enabled,
		BlankTime:   src.DPMS.BlankTime,
		StandbyTime: src.DPMS.StandbyTime,
		SuspendTime: src.DPMS.SuspendTime,
		OffTime:     src.DPMS.OffTime,
	}
}