package coreobjects

import (
	"fmt"

	settings "github.com/DegustatorPonos/RuinesOfRafdolon/Settings"
	rl "github.com/gen2brain/raylib-go/raylib"
)

// The size of the font used in the overaly
const objectOverlayTextSize int32 = 12
// An offset of the overlay compared to the mouse position
const objectOveralyOffset float32 = 10
// An offset of the overlay compared to the mouse position
const objectOveralyPadding int32 = 3
// The color of the overlay text
var objectOverlayTextColor = rl.Black
// The color of the overlay background
var objectOverlayBackgroundColor = rl.LightGray

// An object loaded from the package. Impmiments GameObject interface
type DynamicObject struct {
	PrototypeName string `json:"-"`
	Position rl.Vector2
	YLevelOffset float32
	Textures []*TextureBlock
	Colliders []*ColliderBlock

	parentScene Scene
	showTooltip bool
}

// The dynamic objects can contain multiple textures. This struct
// represents one of those parts
type TextureBlock struct {
	Texture *rl.Texture2D
	// The space occupied by the sprite in world relative to the base object position
	Window *rl.Rectangle

	// The base rectangle of the texture (calculated once in the initialization step)
	baseRect *rl.Rectangle
}

// Inintializes the texture block for futher render
func (base *TextureBlock) init() {
	base.baseRect = &rl.Rectangle{
		X: 0,
		Y: 0,
		Height: float32(base.Texture.Height),
		Width: float32(base.Texture.Width),
	}
}

func (base *TextureBlock) draw(objPos *rl.Vector2) {
	var targetWindow = rl.Rectangle {
		X: base.Window.X + objPos.X,
		Y: base.Window.Y + objPos.Y,
		Width: base.Window.Width,
		Height: base.Window.Height,
	}
	rl.DrawTexturePro(*base.Texture,
		*base.baseRect,
		targetWindow,
		rl.Vector2Zero(),
		0, rl.White)
}

type ColliderBlock struct {
	Collider Collider
	Offset rl.Vector2
}

func (base *DynamicObject) Init(manager *SceneManager) {
	if manager.SelectedScene == nil {
		panic("Failed to initialize a dynamic object: the scene was not selected")
	}
	base.parentScene = manager.SelectedScene
	for _, v := range base.Textures {
		v.init()
	}
}

func (base *DynamicObject) Destroy() {
}

func (base *DynamicObject) Update() {
	if settings.State.DrawColliders {
		base.showTooltip = false
		var mousePosition = base.parentScene.GetMousePosition()
		for _, v := range base.Colliders {
			if v.Collider.Intersects(mousePosition.X, mousePosition.Y) {
				base.showTooltip = true
				return
			}
		}
	}
}

func (base *DynamicObject) drawOverlay() {
	var mousePoint = base.parentScene.GetMousePosition()
	var text = fmt.Sprintf("Proto: %s", base.PrototypeName)
	var overlayPosX = mousePoint.X + objectOveralyOffset
	var overlayPosY = mousePoint.Y
	var size = rl.MeasureText(text, objectOverlayTextSize)

	rl.DrawRectangle(
		int32(overlayPosX), 
		int32(overlayPosY),
		size + objectOveralyPadding * 2,
		objectOverlayTextSize + objectOveralyPadding, 
		objectOverlayBackgroundColor)

	rl.DrawText(string(text), 
		int32(overlayPosX) + objectOveralyPadding, 
		int32(overlayPosY),
		objectOverlayTextSize,
		objectOverlayTextColor)
}

func (base *DynamicObject) Draw() {
	for _, v := range base.Textures {
		v.draw(&base.Position)
	}
	if settings.State.DrawColliders {
		for _, v := range base.Colliders {
			v.Collider.Draw()
			if base.showTooltip {
				base.drawOverlay()
			}
		}
	}
}

func (base *DynamicObject) MoveTo(x float32, y float32) {
	base.Position = rl.Vector2 { X: x, Y: y }
	for _, v := range base.Colliders {
		v.Collider.MoveTo(x + v.Offset.X, y + v.Offset.Y)
	}
}

func (base *DynamicObject) Clone() *DynamicObject {
	var outp = DynamicObject {
		PrototypeName: base.PrototypeName,
		YLevelOffset: base.YLevelOffset,
		Position: base.Position,
		Textures: base.Textures,
		Colliders: base.cloneColliders(),
	}
	return &outp
}

func (base *DynamicObject) cloneColliders() []*ColliderBlock {
	var outp = make([]*ColliderBlock, len(base.Colliders))
	for i, v := range base.Colliders {
		 outp[i] = &ColliderBlock {
			Collider: v.Collider.Clone(),
			Offset: v.Offset,
		}
	}
	return outp
}

func (base *DynamicObject) GetColliders() []Collider {
	var outp = make([]Collider, 0, len(base.Colliders))
	for _, v := range base.Colliders {
		outp = append(outp, v.Collider)
	}
	return outp
}

func (base *DynamicObject) GetYIndex() float32 {
	return base.Position.Y + base.YLevelOffset
}