//go:build windows

package capture

import (
	"fmt"
	"image"
	"time"
	"unsafe"
)

type H264SmokeResolution struct {
	Width  int `json:"width"`
	Height int `json:"height"`
}

type H264SmokeOptions struct {
	Frames      int                   `json:"frames"`
	Resolutions []H264SmokeResolution `json:"resolutions"`
	FPS         []int                 `json:"fps"`
	Providers   []string              `json:"providers"`
}

type H264SmokeResult struct {
	Provider       string  `json:"provider"`
	Input          string  `json:"input"`
	Width          int     `json:"width"`
	Height         int     `json:"height"`
	RequestedFPS   int     `json:"requested_fps"`
	ConfiguredFPS  int     `json:"configured_fps"`
	ConfigureOK    bool    `json:"configure_ok"`
	EncodeOK       bool    `json:"encode_ok"`
	ConfigureMS    float64 `json:"configure_ms"`
	FramesTried    int     `json:"frames_tried"`
	FramesWithData int     `json:"frames_with_data"`
	FirstOutputAt  int     `json:"first_output_at"`
	FirstOutputMS  float64 `json:"first_output_ms"`
	AvgEncodeMS    float64 `json:"avg_encode_ms"`
	MaxEncodeMS    float64 `json:"max_encode_ms"`
	AvgBytes       float64 `json:"avg_bytes"`
	TotalBytes     int     `json:"total_bytes"`
	Error          string  `json:"error,omitempty"`
	Asynchronous   bool    `json:"asynchronous"`
}

type H264MFTFinding struct {
	Index        int    `json:"index"`
	Name         string `json:"name"`
	HardwareURL  string `json:"hardware_url,omitempty"`
	Asynchronous bool   `json:"asynchronous"`
	D3D11Aware   bool   `json:"d3d11_aware"`
	ActivationOK bool   `json:"activation_ok"`
	Error        string `json:"error,omitempty"`
}

type AMFSmokeResult struct {
	Available bool   `json:"available"`
	Detail    string `json:"detail"`
}

func RunAMFSmoke() AMFSmokeResult {
	ok, detail := probeAMFD3D11()
	return AMFSmokeResult{Available: ok, Detail: detail}
}

func FindH264HardwareMFTs() ([]H264MFTFinding, error) {
	if err := ensureMFStartup(); err != nil {
		return nil, err
	}
	input := mftRegisterTypeInfo{majorType: MFMediaType_Video, subtype: MFVideoFormat_NV12}
	output := mftRegisterTypeInfo{majorType: MFMediaType_Video, subtype: MFVideoFormat_H264}
	var activates **mfActivate
	var count uint32
	hr, _, _ := procMFTEnumEx.Call(
		uintptr(unsafe.Pointer(&MFT_CATEGORY_VIDEO_ENCODER)),
		uintptr(mftEnumFlagSyncMFT|mftEnumFlagAsyncMFT|mftEnumFlagHardware|mftEnumFlagSortAndFilter),
		uintptr(unsafe.Pointer(&input)), uintptr(unsafe.Pointer(&output)),
		uintptr(unsafe.Pointer(&activates)), uintptr(unsafe.Pointer(&count)),
	)
	if failedHR(hr) {
		return nil, fmt.Errorf("MFTEnumEx failed 0x%x", hr)
	}
	if activates == nil || count == 0 {
		return []H264MFTFinding{}, nil
	}
	defer procMFCoTaskMemFree.Call(uintptr(unsafe.Pointer(activates)))
	list := unsafe.Slice(activates, int(count))
	findings := make([]H264MFTFinding, 0, len(list))
	for index, activate := range list {
		finding := H264MFTFinding{Index: index}
		if activate == nil {
			finding.Error = "nil activation object"
			findings = append(findings, finding)
			continue
		}
		finding.Name, _ = activate.attrs().GetAllocatedString(&MFT_FRIENDLY_NAME_Attribute)
		finding.HardwareURL, _ = activate.attrs().GetAllocatedString(&MFT_ENUM_HARDWARE_URL_Attribute)
		var transform *mfTransform
		hr := activate.ActivateObject(&IID_IMFTransform, unsafe.Pointer(&transform))
		if failedHR(hr) || transform == nil {
			finding.Error = fmt.Sprintf("ActivateObject failed 0x%x", hr)
		} else {
			finding.ActivationOK = true
			var attrs *mfAttributes
			if !failedHR(transform.GetAttributes(&attrs)) && attrs != nil {
				var async, d3d11 uint32
				_ = attrs.GetUINT32(&MF_TRANSFORM_ASYNC, &async)
				_ = attrs.GetUINT32(&MF_SA_D3D11_AWARE, &d3d11)
				finding.Asynchronous = async != 0
				finding.D3D11Aware = d3d11 != 0
				attrs.Release()
			}
			transform.Release()
		}
		activate.Release()
		findings = append(findings, finding)
	}
	return findings, nil
}

func DefaultH264SmokeOptions() H264SmokeOptions {
	return H264SmokeOptions{
		Frames: 30,
		Resolutions: []H264SmokeResolution{
			{Width: 1280, Height: 720},
			{Width: 1920, Height: 1080},
			{Width: 2560, Height: 1440},
			{Width: 3840, Height: 2160},
		},
		FPS:       []int{30, 60, 120},
		Providers: []string{"hardware", "software"},
	}
}

func RunH264Smoke(opts H264SmokeOptions) []H264SmokeResult {
	opts = normalizeH264SmokeOptions(opts)
	out := make([]H264SmokeResult, 0, len(opts.Resolutions)*len(opts.FPS)*len(opts.Providers)*4)
	for _, res := range opts.Resolutions {
		if res.Width <= 0 || res.Height <= 0 || res.Width%2 != 0 || res.Height%2 != 0 {
			out = append(out, H264SmokeResult{Width: res.Width, Height: res.Height, Error: "resolution must be positive and even"})
			continue
		}
		for _, fps := range opts.FPS {
			for _, provider := range opts.Providers {
				for _, candidate := range h264SmokeCandidates(provider, fps) {
					out = append(out, runH264SmokeCase(provider, res.Width, res.Height, fps, candidate, opts.Frames))
				}
			}
		}
	}
	return out
}

func normalizeH264SmokeOptions(opts H264SmokeOptions) H264SmokeOptions {
	def := DefaultH264SmokeOptions()
	if opts.Frames <= 0 {
		opts.Frames = def.Frames
	}
	if len(opts.Resolutions) == 0 {
		opts.Resolutions = def.Resolutions
	}
	if len(opts.FPS) == 0 {
		opts.FPS = def.FPS
	}
	if len(opts.Providers) == 0 {
		opts.Providers = def.Providers
	}
	return opts
}

func h264SmokeCandidates(provider string, requestedFPS int) []mfH264Candidate {
	if provider == "hardware" {
		return hardwareH264Candidates(requestedFPS)
	}
	return []mfH264Candidate{
		{fps: requestedFPS, inputSubtype: MFVideoFormat_NV12, inputFormat: "NV12"},
		{fps: requestedFPS, inputSubtype: MFVideoFormat_I420, inputFormat: "I420"},
	}
}

func runH264SmokeCase(provider string, width, height, requestedFPS int, candidate mfH264Candidate, frames int) H264SmokeResult {
	result := H264SmokeResult{
		Provider:      provider,
		Input:         candidate.inputFormat,
		Width:         width,
		Height:        height,
		RequestedFPS:  requestedFPS,
		ConfiguredFPS: candidate.fps,
		FirstOutputAt: -1,
	}
	if err := ensureMFStartup(); err != nil {
		result.Error = err.Error()
		return result
	}

	transform, hardware, providerName, err := createH264SmokeTransform(provider)
	if err != nil {
		result.Error = err.Error()
		return result
	}
	result.Provider = providerName
	enc := newMFH264EncoderFromTransform(transform, width, height, requestedFPS, candidate.fps, hardware, providerName, candidate.inputSubtype, candidate.inputFormat)

	t0 := time.Now()
	configureErr := enc.configure()
	result.Asynchronous = enc.asynchronous
	if configureErr != nil {
		result.ConfigureMS = float64(time.Since(t0).Microseconds()) / 1000
		result.Error = configureErr.Error()
		enc.Close()
		return result
	}
	result.ConfigureOK = true
	result.ConfigureMS = float64(time.Since(t0).Microseconds()) / 1000
	defer enc.Close()

	img := image.NewRGBA(image.Rect(0, 0, width, height))
	totalEncode := time.Duration(0)
	maxEncode := time.Duration(0)
	firstStart := time.Now()
	for frame := 0; frame < frames; frame++ {
		fillH264SmokeFrame(img, frame)
		encStart := time.Now()
		data, err := enc.Encode(img)
		encDur := time.Since(encStart)
		result.FramesTried++
		totalEncode += encDur
		if encDur > maxEncode {
			maxEncode = encDur
		}
		if err != nil {
			result.Error = err.Error()
			return result
		}
		if len(data) > 0 {
			result.FramesWithData++
			result.TotalBytes += len(data)
			if result.FirstOutputAt < 0 {
				result.FirstOutputAt = frame + 1
				result.FirstOutputMS = float64(time.Since(firstStart).Microseconds()) / 1000
			}
		}
	}
	if result.FramesTried > 0 {
		result.AvgEncodeMS = float64(totalEncode.Microseconds()) / 1000 / float64(result.FramesTried)
		result.MaxEncodeMS = float64(maxEncode.Microseconds()) / 1000
	}
	if result.FramesWithData > 0 {
		result.EncodeOK = true
		result.AvgBytes = float64(result.TotalBytes) / float64(result.FramesWithData)
	}
	if !result.EncodeOK {
		result.Error = "configured but produced no output"
	}
	return result
}

func createH264SmokeTransform(provider string) (*mfTransform, bool, string, error) {
	switch provider {
	case "hardware":
		transform, detail, err := activateHardwareH264MFTDetailed()
		if err != nil {
			return nil, false, "hardware", err
		}
		return transform, true, detail.provider(), nil
	case "software":
		return createSoftwareH264Transform()
	default:
		return nil, false, provider, fmt.Errorf("unknown provider %q", provider)
	}
}

func fillH264SmokeFrame(img *image.RGBA, frame int) {
	width := img.Bounds().Dx()
	height := img.Bounds().Dy()
	for y := 0; y < height; y++ {
		row := img.Pix[y*img.Stride:]
		for x := 0; x < width; x++ {
			i := x * 4
			row[i+0] = byte((x + frame*7) & 0xff)
			row[i+1] = byte((y + frame*5) & 0xff)
			row[i+2] = byte((x/2 + y/3 + frame*11) & 0xff)
			row[i+3] = 255
		}
	}
}