package main

import (
	"fmt"
	"strconv"

	"gopkg.in/ini.v1"
)

type RoomIni struct {
	night int
	room int

	size float64
	speed float64
	fov float64
	textureRepeat float64
	roomHeight float64
	layerFrames int
	fogColor int
	fogEnd float64
	miniSpeed float64
}

func (r *RoomIni) ToIni() string {
	f := func(n float64) string {
		return strconv.FormatFloat(n, 'f', -1, 64)
	}

	return fmt.Sprintf(`
[NIGHT_%d_ROOM_%d]
size=%s
speed=%s
FOV=%s
Texture_Repeat=%s
Room_Height=%s
Layer_Frames=%d
Fog_Color=%d
Fog_End=%s
Mini_speed=%s
`,
	r.night, r.room,
	f(r.size), f(r.speed),
	f(r.fov), f(r.textureRepeat),
	f(r.roomHeight), r.layerFrames,
	r.fogColor, f(r.fogEnd),
	f(r.miniSpeed),
)
}

func NewRoomIni() RoomIni {
	return RoomIni {
		night: -1,
		room: -1,

		size: 1,
		speed: 1,
		fov: 55,
		textureRepeat: 3,
		roomHeight: 350,
		layerFrames: 1,
		fogColor: 0,
		fogEnd: -1,
		miniSpeed: 1,
	}
}

func ReadIni(path string) (RoomIni, error) {
	cfg, err := ini.InsensitiveLoad(path)
	if err != nil {
		return RoomIni{}, err
	}

	
	meta, err := cfg.GetSection("DEFAULT")
	if err != nil {
		return RoomIni{}, fmt.Errorf("unable to load DEFAULT section in %s: %+v", path, err)
	}

	sections := cfg.Sections()
	var room *ini.Section = nil

	for _, sec := range sections {
		if room != nil {
			fmt.Printf("WARN: extra section in %s, section: %s\n", path, sec.Name())
			continue
		}
		if sec.Name() != "default" {
			room = sec
		}
	}

	roomIni, err := loadIni(meta, room)
	if err != nil {
		return RoomIni{}, fmt.Errorf("ERROR: error loading ini from %s: %+v", path, err)
	}

	return roomIni, nil
}

func loadIni(meta *ini.Section, room *ini.Section) (RoomIni, error) {
	roomini := RoomIni{}

	if val, err := loadInt(meta, "night", -1); err != nil {
		return RoomIni{}, err
	} else {
		roomini.night = val
	}

	if val, err := loadInt(meta, "room", -1); err != nil {
		return RoomIni{}, err
	} else {
		roomini.room = val
	}

	if roomini.night > 0 && roomini.room < 1 {
		return RoomIni{}, fmt.Errorf("night is set but room is not set")
	}


	if val, err := loatFloat(room, "size", 1); err != nil {
		return RoomIni{}, err
	} else {
		roomini.size = val
	}

	if val, err := loatFloat(room, "speed", 1); err != nil {
		return RoomIni{}, err
	} else {
		roomini.speed = val
	}

	if val, err := loatFloat(room, "fov", 55); err != nil {
		return RoomIni{}, err
	} else {
		roomini.fov = val
	}

	if val, err := loatFloat(room, "texture_repeat", 3); err != nil {
		return RoomIni{}, err
	} else {
		roomini.textureRepeat = val
	}

	if val, err := loatFloat(room, "room_height", 350); err != nil {
		return RoomIni{}, err
	} else {
		roomini.roomHeight = val
	}

	if val, err := loadInt(room, "layer_frames", 1); err != nil {
		return RoomIni{}, err
	} else {
		roomini.layerFrames = val
	}

	if val, err := loadInt(room, "fog_color", 0); err != nil {
		return RoomIni{}, err
	} else {
		roomini.fogColor = val
	}

	if val, err := loatFloat(room, "fog_end", -1); err != nil {
		return RoomIni{}, err
	} else {
		roomini.fogEnd = val
	}

	if val, err := loatFloat(room, "mini_speed", 1); err != nil {
		return RoomIni{}, err
	} else {
		roomini.miniSpeed = val
	}

	return roomini, nil

}

func loadInt(sec *ini.Section, key string, def int) (int, error) {
	val, err := sec.GetKey(key)
	if err != nil {
		return def, nil
	}
	valint, err := val.Int()
	if err != nil {
		return def, err
	}
	return valint, nil
}

func loatFloat(sec *ini.Section, key string, def float64) (float64, error) {
	val, err := sec.GetKey(key)
	if err != nil {
		return def, nil
	}
	valfloat, err := val.Float64()
	if err != nil {
		return def, err
	}
	return valfloat, nil
}