package levels

import (
	"fmt"

	mgl "github.com/go-gl/mathgl/mgl32"
	"github.com/inkyblackness/imgui-go/v3"

	"github.com/inkyblackness/hacked/editor/graphics"
	"github.com/inkyblackness/hacked/editor/render"
	"github.com/inkyblackness/hacked/ss1/content/archive/level"
	"github.com/inkyblackness/hacked/ss1/content/object"
	"github.com/inkyblackness/hacked/ss1/edit"
	"github.com/inkyblackness/hacked/ss1/resource"
	"github.com/inkyblackness/hacked/ss1/world/ids"
	"github.com/inkyblackness/hacked/ui/input"
	"github.com/inkyblackness/hacked/ui/opengl"
)

const contextMenuName = "MapContextMenu"

// MapDisplay renders a level map.
type MapDisplay struct {
	gameObjects    *edit.GameObjectsService
	levelSelection *edit.LevelSelectionService
	editor         *edit.LevelEditorService

	context  render.Context
	camera   *LimitedCamera
	guiScale float32

	background  *BackgroundGrid
	textures    *MapTextures
	colors      *MapColors
	mapGrid     *MapGrid
	highlighter *Highlighter
	icons       *MapIcons

	moveCapture func(pixelX, pixelY float32)
	mouseMoved  bool

	positionPopupPos     imgui.Vec2
	positionValid        bool
	position             MapPosition
	contextMenuRequested bool

	selectionReference *level.TilePosition

	hoverItems hoverItems
}

// NewMapDisplay returns a new instance.
func NewMapDisplay(gameObjects *edit.GameObjectsService, levelSelection *edit.LevelSelectionService, editor *edit.LevelEditorService,
	gl opengl.OpenGL, guiScale float32,
	textureQuery TextureQuery) *MapDisplay {
	tilesPerMapSide := float32(64)

	tileBaseLength := float32(level.FineCoordinatesPerTileSide)
	tileBaseHalf := tileBaseLength / 2.0
	camLimit := tilesPerMapSide*tileBaseLength - tileBaseHalf
	zoomShift := guiScale - 1.0
	zoomLevelMin := float32(-5) + zoomShift
	zoomLevelMax := float32(1) + zoomShift

	display := &MapDisplay{
		gameObjects:    gameObjects,
		levelSelection: levelSelection,
		editor:         editor,
		context: render.Context{
			OpenGL:           gl,
			ProjectionMatrix: mgl.Ident4(),
		},
		camera:      NewLimitedCamera(zoomLevelMin, zoomLevelMax, -tileBaseHalf, camLimit),
		guiScale:    guiScale,
		moveCapture: func(float32, float32) {},
	}
	display.context.ViewMatrix = display.camera.ViewMatrix()
	display.background = NewBackgroundGrid(&display.context)
	display.textures = NewMapTextures(&display.context, textureQuery)
	display.colors = NewMapColors(&display.context)
	display.mapGrid = NewMapGrid(&display.context)
	display.highlighter = NewHighlighter(&display.context)
	display.icons = NewMapIcons(&display.context)

	centerX, centerY := (tilesPerMapSide*tileBaseLength)/-2.0, (tilesPerMapSide*tileBaseLength)/-2.0
	display.camera.ZoomAt(-3+zoomShift, centerX, centerY)
	display.camera.MoveTo(centerX, centerY)

	return display
}

// Render renders the whole map display.
func (display *MapDisplay) Render(
	paletteTexture *graphics.PaletteTexture, textureRetriever func(resource.Key) (*graphics.BitmapTexture, error),
	textureDisplay TextureDisplay, colorDisplay ColorDisplay) {
	lvl := display.editor.Level()
	columns, rows, _ := lvl.Size()

	display.hoverItems.validate(lvl)

	display.background.Render(columns, rows)
	if lvl.IsCyberspace() {
		display.renderCyberspaceColors(lvl, columns, rows, paletteTexture, colorDisplay)
	} else {
		display.renderRealWorldTextures(lvl, columns, rows, paletteTexture, textureDisplay)
		display.renderRealWorldShadows(lvl, columns, rows, colorDisplay)
	}
	display.mapGrid.Render(columns, rows, lvl)
	display.renderTileSelection()
	display.renderObjectBackgrounds(lvl)
	display.renderObjectIcons(lvl, paletteTexture, textureRetriever)
	display.renderObjectSelection()
	display.renderActiveHoverItem()
	display.renderPositionOverlay(lvl)
	display.renderContextMenu()
}

func (display *MapDisplay) renderCyberspaceColors(lvl *level.Level, columns int, rows int, paletteTexture *graphics.PaletteTexture, colorDisplay ColorDisplay) {
	if paletteTexture == nil {
		return
	}
	var colorQuery ColorQuery
	palette := paletteTexture.Palette()
	if colorDisplay == ColorDisplayFloor {
		colorQuery = display.colorQueryFor(lvl, func(tile *level.TileMapEntry) [4]float32 {
			rgb := palette[tile.TextureInfo.FloorPaletteIndex()]
			return [4]float32{float32(rgb.Red) / 255, float32(rgb.Green) / 255, float32(rgb.Blue) / 255, 0.8}
		})
	} else if colorDisplay == ColorDisplayCeiling {
		colorQuery = display.colorQueryFor(lvl, func(tile *level.TileMapEntry) [4]float32 {
			rgb := palette[tile.TextureInfo.CeilingPaletteIndex()]
			return [4]float32{float32(rgb.Red) / 255, float32(rgb.Green) / 255, float32(rgb.Blue) / 255, 0.8}
		})
	}
	if colorQuery != nil {
		display.colors.Render(columns, rows, colorQuery)
	}
}

func (display *MapDisplay) renderRealWorldTextures(lvl *level.Level, columns int, rows int,
	paletteTexture *graphics.PaletteTexture, textureDisplay TextureDisplay) {
	if paletteTexture == nil {
		return
	}
	display.textures.Render(columns, rows, func(pos level.TilePosition) (level.TileType, level.TextureIndex, int) {
		tile := lvl.Tile(pos)
		if tile == nil {
			return level.TileTypeSolid, 0, 0
		}
		atlasIndex, textureRotations := textureDisplay.Func()(tile)
		atlas := lvl.TextureAtlas()
		textureIndex := level.TextureIndex(-1)
		if (int(atlasIndex) >= 0) && (int(atlasIndex) < len(atlas)) {
			textureIndex = atlas[atlasIndex]
		}
		return tile.Type, textureIndex, textureRotations
	}, paletteTexture)
}

func (display *MapDisplay) renderRealWorldShadows(lvl *level.Level, columns int, rows int, colorDisplay ColorDisplay) {
	var colorQuery ColorQuery
	if colorDisplay == ColorDisplayFloor {
		colorQuery = display.colorQueryFor(lvl, func(tile *level.TileMapEntry) [4]float32 {
			return [4]float32{0.0, 0.0, 0.0, float32(tile.Flags.ForRealWorld().FloorShadow()) / 15.0}
		})
	} else if colorDisplay == ColorDisplayCeiling {
		colorQuery = display.colorQueryFor(lvl, func(tile *level.TileMapEntry) [4]float32 {
			return [4]float32{0.0, 0.0, 0.0, float32(tile.Flags.ForRealWorld().CeilingShadow()) / 15.0}
		})
	}
	if colorQuery != nil {
		display.colors.Render(columns, rows, colorQuery)
	}
}

func (display *MapDisplay) renderTileSelection() {
	selectedTiles := display.levelSelection.CurrentSelectedTiles()
	tileMapPositions := make([]MapPosition, 0, len(selectedTiles))
	for _, pos := range selectedTiles {
		tileMapPositions = append(tileMapPositions, MapPosition{
			X: level.CoordinateAt(pos.X, level.FineCoordinatesPerTileSide/2),
			Y: level.CoordinateAt(pos.Y, level.FineCoordinatesPerTileSide/2),
		})
	}
	display.highlighter.Render(tileMapPositions, level.FineCoordinatesPerTileSide, [4]float32{0.0, 0.8, 0.2, 0.5})
}

func (display *MapDisplay) renderObjectBackgrounds(lvl *level.Level) {
	var objects []MapPosition
	lvl.ForEachObject(func(id level.ObjectID, entry level.ObjectMainEntry) {
		objects = append(objects, MapPosition{X: entry.X, Y: entry.Y})
	})
	display.highlighter.Render(objects, level.FineCoordinatesPerTileSide/4, [4]float32{1.0, 1.0, 1.0, 0.3})
}

func (display *MapDisplay) renderObjectIcons(lvl *level.Level, paletteTexture *graphics.PaletteTexture,
	textureRetriever func(resource.Key) (*graphics.BitmapTexture, error)) {
	if paletteTexture == nil {
		return
	}
	tripleInfo := display.gameObjects.BitmapInfo()
	var icons []iconData
	var highlightIcon iconData
	var highlightID level.ObjectID

	if display.hoverItems.activeItem != nil {
		objectItem, isObject := display.hoverItems.activeItem.(objectHoverItem)
		if isObject {
			highlightID = objectItem.id
		}
	}
	lvl.ForEachObject(func(id level.ObjectID, entry level.ObjectMainEntry) {
		triple := entry.Triple()
		info, cached := tripleInfo[triple]
		if !cached {
			return
		}
		key := resource.KeyOf(ids.ObjectBitmaps, resource.LangAny, info.Start+info.IconRecommendation)
		texture, err := textureRetriever(key)
		if err == nil {
			icon := iconData{pos: MapPosition{X: entry.X, Y: entry.Y}, texture: texture}
			if highlightID == id {
				highlightIcon = icon
			} else {
				icons = append(icons, icon)
			}
		}
	})
	if (highlightID != 0) && (highlightIcon.texture != nil) {
		icons = append(icons, highlightIcon)
	}
	display.icons.Render(paletteTexture, level.FineCoordinatesPerTileSide/4, icons)
}

func (display *MapDisplay) renderObjectSelection() {
	selectedObjects := display.editor.Objects()
	selectedObjectHighlights := make([]MapPosition, 0, len(selectedObjects))
	for _, obj := range selectedObjects {
		objPos := MapPosition{X: obj.X, Y: obj.Y}
		selectedObjectHighlights = append(selectedObjectHighlights, objPos)
	}
	display.highlighter.Render(selectedObjectHighlights, level.FineCoordinatesPerTileSide/4, [4]float32{0.0, 0.8, 0.2, 0.5})
}

func (display *MapDisplay) renderActiveHoverItem() {
	if display.hoverItems.activeItem == nil {
		return
	}
	display.highlighter.Render(
		[]MapPosition{display.hoverItems.activeItem.Pos()},
		display.hoverItems.activeItem.Size(),
		[4]float32{0.0, 0.2, 0.8, 0.3})
}

func (display *MapDisplay) colorQueryFor(lvl *level.Level, tileToColor func(*level.TileMapEntry) [4]float32) func(level.TilePosition) [4]float32 {
	return func(pos level.TilePosition) [4]float32 {
		tile := lvl.Tile(pos)
		if tile == nil {
			return [4]float32{}
		}
		return tileToColor(tile)
	}
}

func (display *MapDisplay) renderPositionOverlay(lvl *level.Level) {
	imgui.SetNextWindowPosV(display.positionPopupPos, imgui.ConditionAlways, imgui.Vec2{X: 1.0, Y: 1.0})
	imgui.SetNextWindowSize(imgui.Vec2{X: 140 * display.guiScale, Y: 0})
	imgui.SetNextWindowBgAlpha(0.3)
	if imgui.BeginV("Position", nil, imgui.WindowFlagsNoMove|imgui.WindowFlagsNoTitleBar|imgui.WindowFlagsNoResize|imgui.WindowFlagsAlwaysAutoResize|
		imgui.WindowFlagsNoSavedSettings|imgui.WindowFlagsNoFocusOnAppearing|imgui.WindowFlagsNoNav) {
		typeString := "---"
		hasPos := false
		var pos MapPosition
		hasFloor := false
		var floorRaw int
		floorString := hintUnknown
		hasCeiling := false
		var ceilingRaw int
		ceilingString := hintUnknown

		if display.hoverItems.activeItem != nil {
			pos = display.hoverItems.activeItem.Pos()
			hasPos = true

			if _, isTileItem := display.hoverItems.activeItem.(tileHoverItem); isTileItem {
				pos = display.position // use raw cursor position for this display
				typeString = "Tile"
				tile := lvl.Tile(pos.Tile())
				if (tile != nil) && (tile.Type != level.TileTypeSolid) {
					_, _, heightShift := lvl.Size()
					floorHeight := tile.Floor.AbsoluteHeight()
					floorHeightInTiles, err := heightShift.ValueFromTileHeight(floorHeight)
					if err == nil {
						floorString = fmt.Sprintf("%2.3f", floorHeightInTiles)
					}
					floorRaw = int(floorHeight)
					hasFloor = true

					ceilingHeight := tile.Ceiling.AbsoluteHeight()
					ceilingHeightInTiles, err := heightShift.ValueFromTileHeight(ceilingHeight)
					if err == nil {
						ceilingString = fmt.Sprintf("%2.3f", ceilingHeightInTiles)
					}
					ceilingRaw = int(ceilingHeight)
					hasCeiling = true
				}
			} else if objectItem, isObjectItem := display.hoverItems.activeItem.(objectHoverItem); isObjectItem {
				_, _, heightShift := lvl.Size()
				obj := lvl.Object(objectItem.id)
				if obj != nil {
					typeString = fmt.Sprintf("%3d = %v", objectItem.id, obj.Triple())
					heightInTiles, err := heightShift.ValueFromObjectHeight(obj.Z)
					if err == nil {
						floorString = fmt.Sprintf("%2.3f", heightInTiles)
					}
					floorRaw = int(obj.Z)
					hasFloor = true
				}
			}
		}
		imgui.Text("T: " + typeString)
		if hasPos {
			imgui.Text(fmt.Sprintf("X: T %2d F %3d", pos.X.Tile(), pos.X.Fine()))
			imgui.Text(fmt.Sprintf("Y: T %2d F %3d", pos.Y.Tile(), pos.Y.Fine()))
		} else {
			imgui.Text("X: T -- F ---")
			imgui.Text("Y: T -- F ---")
		}
		if hasFloor {
			imgui.Text(fmt.Sprintf("F: %3d = %s", floorRaw, floorString))
		} else {
			imgui.Text("F: -- = --.---")
		}
		if hasCeiling {
			imgui.Text(fmt.Sprintf("C: %3d = %s", ceilingRaw, ceilingString))
		} else {
			imgui.Text("C: -- = --.---")
		}
		imgui.End()
	}
}

func (display *MapDisplay) renderContextMenu() {
	if display.contextMenuRequested {
		imgui.OpenPopup(contextMenuName)
		display.contextMenuRequested = false
	}
	if imgui.BeginPopupV(contextMenuName, imgui.PopupFlagsMouseButtonRight) {
		readOnly := display.editor.IsReadOnly()
		if imgui.BeginMenu("New...") {
			implicitTriple := display.editor.NewObjectTriple()
			canCreateImplicitClass := display.canCreateObjectOf(implicitTriple.Class)
			if imgui.MenuItemV("Object", "Ctrl+2ndClick", false, canCreateImplicitClass) {
				display.requestCreateNewObject(false, implicitTriple)
			}
			if imgui.MenuItemV("Object (at grid)", "Ctrl+Shift+2ndClick", false, canCreateImplicitClass) {
				display.requestCreateNewObject(true, implicitTriple)
			}
			imgui.EndMenu()
		}
		imgui.Separator()
		if imgui.MenuItemV("Delete Objects", "", false, !readOnly && display.editor.HasSelectedObjects()) {
			_ = display.editor.DeleteObjects()
		}
		if imgui.MenuItemV("Clear Tiles", "", false, !readOnly && display.editor.HasSelectedTiles()) {
			_ = display.editor.ClearTiles()
		}
		imgui.EndPopup()
	}
}

// WindowResized must be called to notify of a change in window geometry.
func (display *MapDisplay) WindowResized(width int, height int) {
	display.context.ProjectionMatrix = mgl.Ortho2D(0.0, float32(width), float32(height), 0.0)
	display.camera.SetViewportSize(float32(width), float32(height))
	display.positionPopupPos.X = float32(width) - 10.0
	display.positionPopupPos.Y = float32(height) - 10.0
}

func (display *MapDisplay) unprojectPixel(pixelX, pixelY float32) (x, y float32) {
	pixelVec := mgl.Vec4{pixelX, pixelY, 0.0, 1.0}
	invertedView := display.camera.ViewMatrix().Inv()
	result := invertedView.Mul4x1(pixelVec)

	return result[0], result[1]
}

// MouseButtonDown must be called when a button was pressed.
func (display *MapDisplay) MouseButtonDown(mouseX, mouseY float32, button uint32) {
	display.updateMouseWorldPosition(mouseX, mouseY)
	if button == input.MousePrimary {
		lastPixelX, lastPixelY := mouseX, mouseY

		display.mouseMoved = false
		display.moveCapture = func(pixelX, pixelY float32) {
			lastWorldX, lastWorldY := display.unprojectPixel(lastPixelX, lastPixelY)
			worldX, worldY := display.unprojectPixel(pixelX, pixelY)

			display.camera.MoveBy(worldX-lastWorldX, worldY-lastWorldY)
			lastPixelX, lastPixelY = pixelX, pixelY
			display.mouseMoved = true
		}
	}
}

// MouseButtonUp must be called when a button was released.
func (display *MapDisplay) MouseButtonUp(mouseX, mouseY float32, button uint32, modifier input.Modifier) {
	display.updateMouseWorldPosition(mouseX, mouseY)
	if button == input.MousePrimary {
		display.moveCapture = func(float32, float32) {}
		if !display.mouseMoved && display.positionValid {
			switch {
			case modifier.Has(input.ModControl):
				display.toggleSelectionAtActiveHoverItem()
			case modifier.Has(input.ModShift) && (display.selectionReference != nil):
				firstPos := *display.selectionReference

				fromX := int(firstPos.X)
				fromY := int(firstPos.Y)
				toX := int(display.position.X.Tile())
				toY := int(display.position.Y.Tile())
				xIncrement := 1
				yIncrement := 1
				if fromX > toX {
					xIncrement = -1
				}
				if fromY > toY {
					yIncrement = -1
				}
				toX += xIncrement
				toY += yIncrement
				var newList []level.TilePosition
				for y := fromY; y != toY; y += yIncrement {
					for x := fromX; x != toX; x += xIncrement {
						newList = append(newList, level.TilePosition{X: byte(x), Y: byte(y)})
					}
				}
				display.levelSelection.SetCurrentSelectedTiles(newList)
				display.levelSelection.SetCurrentSelectedObjects(display.objectsInTiles(newList))
			default:
				display.setSelectionByActiveHoverItem()
			}
		}
	} else if button == input.MouseSecondary {
		if modifier.IsClear() {
			display.contextMenuRequested = true
		} else if modifier.Has(input.ModControl) {
			display.requestCreateNewObject(modifier.Has(input.ModShift), display.editor.NewObjectTriple())
		}
	}
}

func (display *MapDisplay) canCreateObjectOf(class object.Class) bool {
	if display.editor.IsReadOnly() {
		return false
	}
	lvl := display.editor.Level()
	return lvl.HasRoomForObjectOf(class) && display.positionValid
}

func (display *MapDisplay) requestCreateNewObject(snapToGrid bool, triple object.Triple) {
	if !display.canCreateObjectOf(triple.Class) {
		return
	}
	pos := display.position
	if snapToGrid {
		toGrid := func(value byte) byte {
			cornerSnapDistance := level.FineCoordinatesPerTileSide / 4
			switch {
			case value < byte(cornerSnapDistance):
				return 0x00
			case value >= byte(level.FineCoordinatesPerTileSide-cornerSnapDistance):
				return level.FineCoordinatesPerTileSide - 1
			default:
				return level.FineCoordinatesPerTileSide / 2
			}
		}
		pos.X = level.CoordinateAt(pos.X.Tile(), toGrid(pos.X.Fine()))
		pos.Y = level.CoordinateAt(pos.Y.Tile(), toGrid(pos.Y.Fine()))
	}
	err := display.editor.CreateNewObject(triple, func(obj *level.ObjectMainEntry) {
		obj.X = pos.X
		obj.Y = pos.Y
	})
	if err != nil {
		panic(err)
	}
}

func (display *MapDisplay) setSelectionByActiveHoverItem() {
	var tiles []level.TilePosition
	var objects []level.ObjectID
	if display.hoverItems.activeItem != nil {
		if tileItem, isTile := display.hoverItems.activeItem.(tileHoverItem); isTile {
			tiles = append(tiles, tileItem.pos.Tile())
		} else if objectItem, isObject := display.hoverItems.activeItem.(objectHoverItem); isObject {
			objects = append(objects, objectItem.id)
		}
	}
	display.levelSelection.SetCurrentSelectedTiles(tiles)
	if len(tiles) > 0 {
		display.selectionReference = &tiles[0]
		display.levelSelection.SetCurrentSelectedObjects(display.objectsInTiles(tiles))
	} else {
		display.levelSelection.SetCurrentSelectedObjects(objects)
	}
}

func (display *MapDisplay) toggleSelectionAtActiveHoverItem() {
	if display.hoverItems.activeItem != nil {
		if tileItem, isTile := display.hoverItems.activeItem.(tileHoverItem); isTile {
			wasSelected := display.levelSelection.IsTileSelected(tileItem.pos.Tile())
			tiles := []level.TilePosition{tileItem.pos.Tile()}
			if wasSelected {
				display.levelSelection.RemoveCurrentSelectedTiles(tiles)
				display.levelSelection.RemoveCurrentSelectedObjects(display.objectsInTiles(tiles))
			} else {
				display.levelSelection.AddCurrentSelectedTiles(tiles)
				display.levelSelection.AddCurrentSelectedObjects(display.objectsInTiles(tiles))
			}
		} else if objectItem, isObject := display.hoverItems.activeItem.(objectHoverItem); isObject {
			display.levelSelection.ToggleObjectSelection([]level.ObjectID{objectItem.id})
		}
	}
}

func (display *MapDisplay) objectsInTiles(tiles []level.TilePosition) []level.ObjectID {
	tilesContain := func(pos level.TilePosition) bool {
		for _, entry := range tiles {
			if entry == pos {
				return true
			}
		}
		return false
	}

	var objects []level.ObjectID
	lvl := display.editor.Level()
	lvl.ForEachObject(func(id level.ObjectID, entry level.ObjectMainEntry) {
		if tilesContain(entry.TilePosition()) {
			objects = append(objects, id)
		}
	})
	return objects
}

// MouseMoved must be called for a mouse move.
func (display *MapDisplay) MouseMoved(mouseX, mouseY float32) {
	display.updateMouseWorldPosition(mouseX, mouseY)
	if display.positionValid {
		display.hoverItems.find(display.editor.Level(), display.position)
	} else {
		display.hoverItems.reset()
	}
	display.moveCapture(mouseX, mouseY)
}

// MouseScrolled must be called for a mouse scroll.
func (display *MapDisplay) MouseScrolled(mouseX, mouseY float32, deltaX, deltaY float32, modifier input.Modifier) {
	if modifier.Has(input.ModControl) {
		display.hoverItems.scroll(deltaY > 0)
	} else {
		worldX, worldY := display.unprojectPixel(mouseX, mouseY)

		if deltaY < 0 {
			display.camera.ZoomAt(-0.5, worldX, worldY)
		}
		if deltaY > 0 {
			display.camera.ZoomAt(0.5, worldX, worldY)
		}
	}
}

func (display *MapDisplay) updateMouseWorldPosition(mouseX, mouseY float32) {
	worldX, worldY := display.unprojectPixel(mouseX, mouseY)
	lvl := display.editor.Level()
	width, height, _ := lvl.Size()
	worldWidth := float32(width) * level.FineCoordinatesPerTileSide
	worldHeight := float32(height) * level.FineCoordinatesPerTileSide

	display.positionValid = (worldX >= 0.0) && (worldX < worldWidth) && (worldY >= 0.0) && (worldY < worldHeight)
	if display.positionValid {
		display.position = MapPosition{X: level.Coordinate(worldX + 0.5), Y: level.Coordinate(worldY + 0.5)}
	} else {
		display.position = MapPosition{}
	}
}