package producer

import (
	"math"
	"time"

	log "github.com/sirupsen/logrus"

	"github.com/duke-git/lancet/v2/mathutil"
	"github.com/paulmach/orb"
	"github.com/paulmach/orb/geo"
	"github.com/paulmach/orb/planar"
	"starwiz.cn/sjy01/image-proc/pkg/auxilary"
	"starwiz.cn/sjy01/image-proc/pkg/calculator"
)

func (r *Registrator) LoadAuxData() error {
	var err error
	r.auxHeads, r.auxBoxes, r.AuxPlatforms, err = auxilary.ExtractAux(r.Params.AuxRawFile)
	return err
}

func (r *Registrator) SceneImageTime(scene *Scene) (start, center, end time.Time) {
	startPosInAux, endPosInAux := r.SceneInAuxIndex(scene)
	centerPosInAux := (startPosInAux + endPosInAux) / 2

	start = time.Unix(int64(auxilary.ReferenceTime2000)+int64(r.AuxPlatforms[startPosInAux].UTCTimeSec),
		int64(r.AuxPlatforms[startPosInAux].Microsecond)*1000)
	center = time.Unix(int64(auxilary.ReferenceTime2000)+int64(r.AuxPlatforms[centerPosInAux].UTCTimeSec),
		int64(r.AuxPlatforms[centerPosInAux].Microsecond)*1000)
	end = time.Unix(int64(auxilary.ReferenceTime2000)+int64(r.AuxPlatforms[endPosInAux].UTCTimeSec),
		int64(r.AuxPlatforms[endPosInAux].Microsecond)*1000)

	return
}

// FIXME: This function is not accurate enough.
func (r *Registrator) SetSceneBoundary(scene *Scene) (topLeft, bottomRight orb.Point) {
	startPosInAux, endPosInAux := r.SceneInAuxIndex(scene)

	as := r.AuxPlatforms[startPosInAux]
	startPos84 := []float64{as.W84PosX, as.W84PosY, as.W84PosZ}
	startTime := time.Unix(int64(auxilary.ReferenceTime2000)+int64(as.UTCTimeSec), int64(as.Microsecond)*1000).UTC()

	ae := r.AuxPlatforms[endPosInAux]
	endPos84 := []float64{ae.W84PosX, ae.W84PosY, ae.W84PosZ}
	endTime := time.Unix(int64(auxilary.ReferenceTime2000)+int64(ae.UTCTimeSec), int64(ae.Microsecond)*1000).UTC()

	// ------------------ 使用定姿态四元数计算图像边界 ------------------
	log.Info("using attitude quaternion to calculate image boundary...")
	Qsat2eci := calculator.Quaternion{W: as.QuatAttstarQ0, X: as.QuatAttstarQ1, Y: as.QuatAttstarQ2, Z: as.QuatAttstarQ3}
	line0Start := calculator.Intersection(Qsat2eci, startPos84, startTime, 0)
	line0End := calculator.Intersection(Qsat2eci, startPos84, startTime, 9344)

	Qsat2eci = calculator.Quaternion{W: ae.QuatAttstarQ0, X: ae.QuatAttstarQ1, Y: ae.QuatAttstarQ2, Z: ae.QuatAttstarQ3}
	lineNStart := calculator.Intersection(Qsat2eci, endPos84, endTime, 0)
	lineNEnd := calculator.Intersection(Qsat2eci, endPos84, endTime, 9344)

	// ------------------ 使用本体和轨道四元数计算图像边界 ------------------
	// log.Info("using orbit and body quaternion to calculate image boundary...")
	// Qsat2orbit := calculator.Quaternion{X: as.QuatOrbitQ1, Y: as.QuatOrbitQ2, Z: as.QuatOrbitQ3}
	// Qsat2orbit.W = math.Sqrt(1 - Qsat2orbit.X*Qsat2orbit.X - Qsat2orbit.Y*Qsat2orbit.Y - Qsat2orbit.Z*Qsat2orbit.Z)
	// Qorbit2eci := calculator.Quaternion{X: as.QuatOrbJQ1, Y: as.QuatOrbJQ2, Z: as.QuatOrbJQ3}
	// Qorbit2eci.W = math.Sqrt(1 - Qorbit2eci.X*Qorbit2eci.X - Qorbit2eci.Y*Qorbit2eci.Y - Qorbit2eci.Z*Qorbit2eci.Z)
	// line0Start = calculator.Intersection2(Qsat2orbit, Qorbit2eci, startPos84, startTime, 0)
	// line0End = calculator.Intersection2(Qsat2orbit, Qorbit2eci, startPos84, startTime, 9344)

	// Qsat2orbit = calculator.Quaternion{X: ae.QuatOrbitQ1, Y: ae.QuatOrbitQ2, Z: ae.QuatOrbitQ3}
	// Qsat2orbit.W = math.Sqrt(1 - Qsat2orbit.X*Qsat2orbit.X - Qsat2orbit.Y*Qsat2orbit.Y - Qsat2orbit.Z*Qsat2orbit.Z)
	// Qorbit2eci = calculator.Quaternion{X: ae.QuatOrbJQ1, Y: ae.QuatOrbJQ2, Z: ae.QuatOrbJQ3}
	// Qorbit2eci.W = math.Sqrt(1 - Qorbit2eci.X*Qorbit2eci.X - Qorbit2eci.Y*Qorbit2eci.Y - Qorbit2eci.Z*Qorbit2eci.Z)
	// lineNStart = calculator.Intersection2(Qsat2orbit, Qorbit2eci, endPos84, endTime, 0)
	// lineNEnd = calculator.Intersection2(Qsat2orbit, Qorbit2eci, endPos84, endTime, 9344)

	// ------------------ 计算图像边界距离和分辨率 ------------------
	W0 := geo.Distance(orb.Point{line0Start.Lon, line0Start.Lat}, orb.Point{line0End.Lon, line0End.Lat})
	// WN := geo.Distance(orb.Point{lineNStart.Lon, lineNStart.Lat}, orb.Point{lineNEnd.Lon, lineNEnd.Lat})
	H0 := geo.Distance(orb.Point{line0Start.Lon, line0Start.Lat}, orb.Point{lineNStart.Lon, lineNStart.Lat})
	// HN := geo.Distance(orb.Point{line0End.Lon, line0End.Lat}, orb.Point{lineNEnd.Lon, lineNEnd.Lat})
	xResolution := W0 / float64(scene.Width)
	yResolution := H0 / float64(scene.Height)
	scene.Meta.Gsd = math.Max(xResolution, yResolution)

	// log.Debug("distance 0: ", W0)
	// log.Debug("distance N: ", WN)
	// log.Debug("distance 0-0: ", H0)
	// log.Debug("distance N-N: ", HN)
	log.Debug("resolution x: ", xResolution)
	log.Debug("resolution y: ", yResolution)

	// 求外接矩形
	latMin := mathutil.Min(line0Start.Lat, line0End.Lat, lineNStart.Lat, lineNEnd.Lat)
	lngMin := mathutil.Min(line0Start.Lon, line0End.Lon, lineNStart.Lon, lineNEnd.Lon)
	latMax := mathutil.Max(line0Start.Lat, line0End.Lat, lineNStart.Lat, lineNEnd.Lat)
	lngMax := mathutil.Max(line0Start.Lon, line0End.Lon, lineNStart.Lon, lineNEnd.Lon)

	poly := orb.Polygon{
		{
			{lngMin, latMin},
			{lngMax, latMin},
			{lngMax, latMax},
			{lngMin, latMax},
			{lngMin, latMin},
		},
	}

	centroid, _ := planar.CentroidArea(poly)
	scene.Meta.CentreLocation.Latitude = centroid.Y()
	scene.Meta.CentreLocation.Longitude = centroid.X()

	// 暂定存储四角点
	scene.Meta.Corners.UpperLeft.Latitude = line0Start.Lat
	scene.Meta.Corners.UpperLeft.Longitude = line0Start.Lon
	scene.Meta.Corners.UpperRight.Latitude = line0End.Lat
	scene.Meta.Corners.UpperRight.Longitude = line0End.Lon
	scene.Meta.Corners.LowerLeft.Latitude = lineNStart.Lat
	scene.Meta.Corners.LowerLeft.Longitude = lineNStart.Lon
	scene.Meta.Corners.LowerRight.Latitude = lineNEnd.Lat
	scene.Meta.Corners.LowerRight.Longitude = lineNEnd.Lon

	scene.Meta.SatPosX = startPos84[0]
	scene.Meta.SatPosY = startPos84[1]
	scene.Meta.SatPosZ = startPos84[2]
	scene.Meta.Yaw = ae.Eular3 * 180 / math.Pi
	scene.Meta.Pitch = ae.Eular2 * 180 / math.Pi
	scene.Meta.Roll = ae.Eular1 * 180 / math.Pi

	return
}

func (r *Registrator) SceneInAuxIndex(scene *Scene) (int, int) {
	var auxForImageRow int
	switch scene.Type {
	case "MSS":
		auxForImageRow = 4
	case "PAN":
		auxForImageRow = 16
	case "FUS":
		auxForImageRow = 16
	}

	startPosInAux := scene.Y / auxForImageRow
	if startPosInAux >= len(r.AuxPlatforms) {
		startPosInAux = len(r.AuxPlatforms) - 1
	}

	endPosInAux := (scene.Y + scene.Height) / auxForImageRow
	if endPosInAux >= len(r.AuxPlatforms) {
		endPosInAux = len(r.AuxPlatforms) - 1
	}

	return startPosInAux, endPosInAux
}