// git clone https://github.com/laytan/odin-http
// vim main.odin
package main
import http "odin-http"

cd myproject
odin build .
odin run main.odin -file

    Payment_Error :: enum {
	    None,
	    Bank_Account_Is_Empty,
    }


    Pay_Half_Debt_Error :: union #shared_nil {
        Payment_Error,
        json.Marshal_Error,
    }

    Save_House_Error :: union #shared_nil {
        Pay_Half_Debt_Error,
        Is_Even_Worth_Saving_Error,
    }
    // etc

    err := Extend_Deadline_Error(
		Save_House_Error(
            Pay_Half_Debt_Error(
                Payment_Error.Bank_Account_Is_Empty
                )
        ),
	)

    #partial switch save_house in err {
	case Save_House_Error:
		pay_half := save_house.(Pay_Half_Debt_Error)
		#partial switch pay in pay_half {
		case Payment_Error:
			#partial switch pay {
			case .Bank_Account_Is_Empty:
				fmt.println("You have 24 hours to leave the house.")
			}
		}
	}

    // this condition works thanks to #shared_nil directive in union
	if err != nil {
		tr := trace.trace(err)
		defer delete(tr) // defer works in scopes
		fmt.println(tr)
	}
// prints: Extend_Deadline_Error -> Save_House_Error -> 
//Pay_Half_Debt_Error -> Payment_Error.Bank_Account_Is_Empty

    n : ^int // this is how you assign pointer type 
    n = new(int) // this is how you create a new pointer 
    assert(n^ == 0) // remember that all pointers have default values
    n^ = 2 // this is how you assign a value to a pointer
    fmt.println(n^) //this is how you read the value from a pointer
    free(n) //this is how you free a pointer

    // make()/delete() is for strings, array and maps. 
    // For the rest of the types use new()/free()
    arr := make([dynamic]int) 
    delete(arr)

    // make(),delete(),new() and free() accept allocators
    // if you don't add an allocator then they use the default.

    // context.allocator is the default allocator
    my_allocator := context.allocator 
    m := new(int, my_allocator)

    // you can also change the default allocator
    context.allocator = my_allocator

    // import "core:mem" has many other types of allocators
    // like Tracking_Allocator to track leaks
    // and Panic_Allocator useful for spaceship software

    arr := make([dynamic]int) 
    delete(arr)
    delete(arr) // causes "Segmentation fault"

	n = new(int)
	n^ = 2
	free(n)
	fmt.println(n^) // it will not print 2 but something random

   	arr := make([dynamic]^int)
	for i in 0 ..< 10 {
		n := new(int)
		n^ = i
		append(&arr, n)
	}
    // if you don't free each item
	// for n in arr {
    //   free(n)
	// }
	
	// then this will leak
	delete(arr)

	global := new(int)

	if global != nil {
		free(global)
		// after deallocation assign nil to the pointer
		global = nil
	}

	// so other procedures can:

	// - check before assign
	if global != nil {
		global^ = 2
	}

	// - check before they read
	if global != nil {
		fmt.println(global^)
	}

	
	// - check for nils and not double free
	if global != nil {
		free(global)
		global = nil
	}

{
	n := new(int)
	defer free(n) 

	n^ = 2
	fmt.println(n^)

	// defer will run the free() here
}

   
	// when a procedure creates a pointer with a deallocator then it has name that ends with _init
    multi_reader_init :: proc(
		mr: ^Multi_Reader, 
		readers: ..Reader, 

		 // always look at the end of parameter lists for "allocator"
		allocator := context.allocator) -> (r: Reader)

	// its deallocator has a name that ends with _destroy
	multi_reader_destroy :: proc(mr: ^Multi_Reader)

	arr_arena: virtual.Arena

    // create arena allocator
	arena_allocator := virtual.arena_allocator(&arr_arena)

    // create the array using the arena allocator
	arr := make([dynamic]^int, allocator = arena_allocator)
	for i in 0 ..< 10 {

		// include the items in the arena
		n := new(int, allocator = arena_allocator)
		n^ = i
		append(&arr, n)
	}

    // delete everything in a single sweep
	virtual.arena_destroy(&arr_arena)

Stringer_Interface :: struct {
	data:   rawptr,
	sprint: proc(
		si: Stringer_Interface, 
		allocator := context.allocator) -> string,
}


Book :: struct {
	name: string,
}


new_stringer_book :: proc(b: ^Book) -> Stringer_Interface {
	return Stringer_Interface {
		data = rawptr(b),
		sprint = proc(si: Stringer_Interface, 
                      allocator := context.allocator) -> string {
            context.allocator = allocator
			data := cast(^Book)si.data
			return fmt.aprint("The name of the book is", data.name)
		},
	}
}

print :: proc(si: Stringer_Interface) {
	str := si->sprint()
	defer delete(str)
	fmt.println(str)
}


main :: proc() {
	odin_book := Book {
		name = "Odin book",
	}
	stringer_book := new_stringer_book(&odin_book)
	print(stringer_book)
}

Shape_Abstract :: struct {
	width:    int,
	height:   int,
	get_area: proc(shape: ^Shape_Abstract) -> int,
}

Penis :: struct {
	using _: Shape_Abstract,
	name:    string,
}

new_penis :: proc(name: string, width, height: int) -> Penis {
	return Penis {
		name = name,
		width = width,
		height = height,
		get_area = proc(shape: ^Shape_Abstract) -> int {
			data := cast(^Penis)shape
			return data.width * data.height
		},
	}
}

print_area :: proc(shape: ^Shape_Abstract) {
	fmt.println("Area:", shape->get_area())
}

main :: proc() {
	my_penis := new_penis("mini me", 5, 23)
	print_area(&my_penis)
}

package main


import "core:fmt"
import "core:mem"
import "core:strconv"
import "core:sync"
import "core:sync/chan"
import "core:thread"
import "core:time"

Parent_Enum :: enum {
	Father,
	Mother,
}

Food_From_Father :: struct {
	papa_index: int,
}

Food_From_Mother :: struct {
	mama_index: int,
}

Food :: union {
	Food_From_Father,
	Food_From_Mother,
}


KidData :: struct {
	kids_wait_group: ^sync.Wait_Group,
	mouth:           ^chan.Chan(Food, chan.Direction.Recv),
}

ParentData :: struct {
	parent_type:        Parent_Enum,
	num_foods:          int,
	parents_wait_group: ^sync.Wait_Group,
	mouth:              ^chan.Chan(Food, chan.Direction.Send),
	mouth_mutex:        ^sync.Mutex,
}

parent_task :: proc(t: ^thread.Thread) {
	data := (cast(^ParentData)t.data)
	fmt.println(data.parent_type, "starts feeding")

	for i in 1 ..= data.num_foods {
		food: Food
		if data.parent_type == .Mother {
			food = Food_From_Mother {
				mama_index = i,
			}
		}
		if data.parent_type == .Father {
			food = Food_From_Father {
				papa_index = i,
			}
		}

		// if you don't add mutex, then at least once, 
		// a parent will send the same food index to two kids
		// while the other parent does not send any food
		// for the same food index (which I don't understand why)
		sync.mutex_lock(data.mouth_mutex)
		chan.send(data.mouth^, food)
		sync.mutex_unlock(data.mouth_mutex)

		// wait to throw up new food
		time.sleep(500 * time.Millisecond)
	}

	sync.wait_group_done(data.parents_wait_group)
	fmt.printfln("%v's feeding stopped", data.parent_type)

}

kid_task :: proc(t: thread.Task) {
	data := (cast(^KidData)t.data)
	fmt.println("kid", t.user_index, "opens mouth")
	for {
		msg, ok := chan.recv(data.mouth^)
		if !ok {
			fmt.println("mouth closed for kid", t.user_index)
			break
		}
		switch food in msg {
		case Food_From_Father:
			fmt.println("kid", t.user_index, 
              "received food", food.papa_index, 
              "from father")
		case Food_From_Mother:
			fmt.println("kid", t.user_index, 
              "received food", food.mama_index, 
              "from mother")
		}

		// wait to chew their food
		time.sleep(time.Second)
	}
	fmt.println("kid", t.user_index, "finished eating")
	sync.wait_group_done(data.kids_wait_group)
	fmt.printfln("kid %d went to bed", t.user_index)
}

main :: proc() {
	parents_wg: sync.Wait_Group
	kids_wg: sync.Wait_Group
	num_kids := 5

	// create feeding pipe
	mouth, err := chan.create(chan.Chan(Food), context.allocator)
	defer chan.destroy(mouth)
	mouth_mutex := sync.Mutex{}

	// create mama bird
	mama_mouth := chan.as_send(mouth)
	mama_thread := thread.create(parent_task)
	defer thread.destroy(mama_thread)
	mama_thread.init_context = context
	mama_thread.user_index = 1
	mama_thread.data = &ParentData {
		parent_type        = .Mother,
		num_foods          = 8, // with more food
		parents_wait_group = &parents_wg,
		mouth              = &mama_mouth,
		mouth_mutex        = &mouth_mutex,
	}

	// create lazy father bird
	papa_mouth := chan.as_send(mouth)
	papa_thread := thread.create(parent_task)
	defer thread.destroy(papa_thread)
	papa_thread.init_context = context
	papa_thread.user_index = 2
	papa_thread.data = &ParentData {
		parent_type        = .Father,
		num_foods          = 6, // with less food
		parents_wait_group = &parents_wg,
		mouth              = &papa_mouth,
		mouth_mutex        = &mouth_mutex,
	}

	sync.wait_group_add(&parents_wg, 2)

	thread.start(mama_thread)
	thread.start(papa_thread)

	// create a nest for kids
	nest: thread.Pool
	thread.pool_init(&nest, 
        allocator = context.allocator, 
        thread_count = num_kids)

	defer thread.pool_destroy(&nest)

	sync.wait_group_add(&kids_wg, num_kids)
	for i in 1 ..= num_kids {
		kid_mouth := chan.as_recv(mouth)
		data := &KidData{
            kids_wait_group = &kids_wg, 
            mouth = &kid_mouth
        }

		// add kid to the nest
		thread.pool_add_task(
			&nest,
			allocator = context.allocator,
			procedure = kid_task,
			data = rawptr(data),
			user_index = i,
		)
	}

	thread.pool_start(&nest)


	// first we wait for parents to stop feeding kids
	sync.wait_group_wait(&parents_wg)
	fmt.println("all parents stopped feeding them")

	// everybody closes their mouths
	chan.close(mouth)
	fmt.println("kids close their mouths")

	// we wait for all kids to sleep
	sync.wait_group_wait(&kids_wg)

	fmt.println("all kids slept")

	// run this or else the program will never close
	thread.pool_finish(&nest)

}