package tide

import "core:os"
import "core:log"
import "core:math"
import "core:strings"
import fmt "core:fmt"
import sdl "vendor:sdl2"
import ttf "vendor:sdl2/ttf"
import txtedit "core:text/edit"

AppState :: struct {
    buffer_dirty: bool,
}

SdlCtx :: struct {
	window:        ^sdl.Window,
	surface:       ^sdl.Surface,
	renderer:      ^sdl.Renderer,
	font:          ^ttf.Font,
    ftex:          ^sdl.Texture,
    text_surface:  ^sdl.Surface,
    buffer_text:   ^BufferText,
	// font_data:     ^FontData,

	should_close:  bool,
	app_start:     f64,

	frame_start:   f64,
	frame_end:     f64,
	frame_elapsed: f64,
}

BufferText :: struct {
    builder:   strings.Builder,
}

FontData :: struct {
    font:    ^ttf.Font,
	texture: ^sdl.Texture,
	rect:     sdl.Rect,
	font_w:   int,
	font_h:   int,
}

WIN_TITLE :: "FIDE"
WIN_X     := i32(0)
WIN_Y     := i32(100)
WIN_W     := i32(950)
WIN_H     := i32(1000)
WIN_FLAGS :: sdl.WindowFlags{.SHOWN}

state := AppState{}
ctx := SdlCtx{}

sdl_init :: proc() -> (ok: bool) {
	ctx.app_start = f64(sdl.GetPerformanceCounter()) / f64(sdl.GetPerformanceFrequency())

    if sdl.Init(sdl.INIT_VIDEO) != 0 {
        return false
    }

	ctx.window = sdl.CreateWindow(WIN_TITLE, WIN_X, WIN_Y, WIN_W, WIN_H, WIN_FLAGS)

	ctx.renderer = sdl.CreateRenderer(ctx.window, -1, {.ACCELERATED, .PRESENTVSYNC})
	if ctx.renderer == nil {
		log.errorf("sdl2.CreateRenderer failed.")
		return false
	}

    if ttf.Init() != 0 {
		log.errorf("sdl.TTF_Init failed.")
        return false
    }

    font_path := cstring("./resources/JetBrainsMono-Regular.otf")
    ctx.font = ttf.OpenFont(font_path, 32)
    if ctx.font == nil {
		log.errorf("sdl.TTF_OpenFont failed.")
        return false
    }


    bt := new(BufferText)
    bt.builder = strings.builder_make(0, 512)
    ctx.buffer_text = bt
    append(&bt.builder.buf, "// Code goes here...")
    return true
}

process_input :: proc() {
	e: sdl.Event

    state.buffer_dirty = true

	for sdl.PollEvent(&e) {
		#partial switch(e.type) {
		case .QUIT:
			ctx.should_close = true
		case .KEYDOWN:
			#partial switch(e.key.keysym.sym) {
			case .ESCAPE:
				ctx.should_close = true
            case .BACKSPACE:
                strings.pop_rune(&ctx.buffer_text.builder)
                state.buffer_dirty = true
                fmt.println("Key Pressed: BACKSPACE")
			}
		}
	}
}

update :: proc() {
    if state.buffer_dirty {

        color := sdl.Color{ 0, 0, 0, 255}

        str := strings.to_cstring(&ctx.buffer_text.builder)
        ctx.text_surface = ttf.RenderText_Blended(ctx.font, str, color);
        if (ctx.text_surface == nil) {
            log.errorf(sdl.GetErrorString())
            os.exit(1)
        }
    }
}

draw :: proc() {
	sdl.SetRenderDrawColor(ctx.renderer, 250, 250, 250, 0xff)
	sdl.RenderClear(ctx.renderer)

    ctx.ftex = sdl.CreateTextureFromSurface(ctx.renderer, ctx.text_surface);

    src := sdl.Rect { 0, 0, ctx.text_surface.w, ctx.text_surface.h }
    dest := sdl.Rect { 0, 0, ctx.text_surface.w, ctx.text_surface.h }

    sdl.RenderCopy(ctx.renderer, ctx.ftex, &src, &dest)

    sdl.RenderPresent(ctx.renderer)
}

main :: proc() {
	context.logger = log.create_console_logger()

    if ok := sdl_init(); !ok {
		log.errorf(sdl.GetErrorString())
        os.exit(1)
    }

	ctx.frame_start   = ctx.app_start
	ctx.frame_elapsed = 0.001

    for !ctx.should_close {
        process_input()
        update()
        draw()

		ctx.frame_end     = f64(sdl.GetPerformanceCounter()) / f64(sdl.GetPerformanceFrequency())
		ctx.frame_elapsed = ctx.frame_end - ctx.frame_start
		ctx.frame_start   = ctx.frame_end
    }

    ttf.CloseFont(ctx.font)
	sdl.DestroyWindow(ctx.window)
	sdl.Quit()
}