package main

import (
	"container/list"
	"fmt"
)

type Element[T any] struct {
	e *list.Element
}

func (e *Element[T]) Value() T {
	return e.e.Value.(T)
}

func (e *Element[T]) Prev() *Element[T] {
	prev := e.e.Prev()
	if prev == nil {
		return nil
	}
	return &Element[T]{e: prev}
}

func (e *Element[T]) Next() *Element[T] {
	next := e.e.Next()
	if next == nil {
		return nil
	}
	return &Element[T]{e: next}
}

type TypedList[T any] struct {
	l *list.List
}

func NewTypedList[T any]() TypedList[T] {
	return TypedList[T]{
		l: list.New(),
	}
}

func (t *TypedList[T]) PushFront(value T) *Element[T] {
	v := t.l.PushFront(value)
	return &Element[T]{e: v}
}

func (t *TypedList[T]) PushBack(value T) *Element[T] {
	v := t.l.PushBack(value)
	return &Element[T]{e: v}
}

func (t *TypedList[T]) Front() *Element[T] {
	front := t.l.Front()
	if front == nil {
		return nil
	}
	return &Element[T]{e: front}
}

func (t *TypedList[T]) Back() *Element[T] {
	back := t.l.Back()
	if back == nil {
		return nil
	}
	return &Element[T]{e: back}
}

func main() {
	a := NewTypedList[string]()
	a.PushFront("test")
	a.PushFront("go")
	a.PushFront("1.18")
	a.PushFront("generics")
	for i := a.Back(); i != nil; i = i.Prev() {
		fmt.Println(i.Value())
	}
}

package faulty_list

import (
	"container/list"
	"fmt"
)

func FaultyListDemo() {
	l := list.New()
	l.PushBack("1")
	l.PushBack(2)
	l.PushBack(3.5)
	for i := l.Front(); i != nil; i = i.Next() {
		fmt.Println("any", i.Value.(any))  // what type is i.Value ?
		if v, ok := i.Value.(string); ok { // checking type every time is quite annoying
			fmt.Println("if string", v)
		}
		fmt.Println("assertion without check", i.Value.(string)) // incorrect type assertion leads to panic
	}
}

package typed_list

import "fmt"

func TypedListDemo() {
	a := NewTypedList[string]()
	a.PushFront("test")
	a.PushFront("go")
	a.PushFront(1.18)  // incorrect type here
	a.PushFront("generics")
	for i := a.Back(); i != nil; i = i.Prev() {
		fmt.Println(i.Value())
	}
}

type Set[T1 comparable] struct {
	m map[T1]bool
}

package min

import (
	"constraints"
	"fmt"
)

func Min[T constraints.Ordered](v0 T, v ...T) T {
	var minT = v0
	for _, x := range v {
		if x < minT {
			minT = x
		}
	}
	return minT
}

func MinT[T constraints.Ordered](v ...T) T {
	var minT = v[0]
	for _, x := range v {
		if x < minT {
			minT = x
		}
	}
	return minT
}

func MinI(v interface{}) interface{} {
	switch vi := v.(type) {
	case []int64:
		{
			return MinT(vi...)
		}
		// other types in constraints.Ordered ...
	}
	// runtime panic for unacceptable type here
	panic("unacceptable slice type")
}

func MinTest() {
	fmt.Println(Min(9, 8, 7, 6, 1, 2, 3, 4, 5) + 10) // 11
	a := []int64{9, 8, 7, 6, 1, 2, 3, 4, 5}
	fmt.Println(MinT(a...) + 11)      // 12
	fmt.Println(MinI(a).(int64) + 12) // 13. type of return value must be asserted

	fmt.Println(Min(9.5, 8.5, 7.5, 6.5, 1.5, 2.5, 3.5, 4.5, 5.5)) // 1.5
	b := []float64{9.5, 8.5, 7.5, 6.5, 1.5, 2.5, 3.5, 4.5, 5.5}
	fmt.Println(MinI(b)) // panic: unacceptable slice type
}

package typed_pair

import "fmt"

type Pair[T1 comparable, T2 any] struct {
	first  T1
	second T2
}

type Map[T1 comparable, T2 any] struct {
	m map[T1]T2
}

func (m *Map[T1, T2]) Set(k T1, v T2) {
	if m.m == nil {
		m.m = map[T1]T2{}
	}
	m.m[k] = v
}

// Items Python 2 Like items() method (unordered as well)
func (m *Map[T1, T2]) Items() []Pair[T1, T2] {
	l := make([]Pair[T1, T2], 0, len(m.m))
	for k, v := range m.m {
		l = append(l, Pair[T1, T2]{first: k, second: v})
	}
	return l
}

func TypedPairDemo() {
	m := Map[string, int]{}
	m.Set("123", 123)
	m.Set("456", 456)
	for _, item := range m.Items() { // so pythonic isn't it ?
		fmt.Println(item.first, item.second)
	}
}

package typed_currying

import "fmt"

func PartialT2R1V2[T1, T2, R1 any](f func(t1 T1, t2 T2) R1, v1 T1, v2 T2) func() R1 {
	return func() R1 {
		return f(v1, v2)
	}
}

func PartialT3R1V1[T1, T2, T3, R1 any](f func(t1 T1, t2 T2, t3 T3) R1, v1 T1) func(v2 T2, v3 T3) R1 {
	return func(v2 T2, v3 T3) R1 {
		return f(v1, v2, v3)
	}
}

func CurryingT3R1[T1, T2, T3, R1 any](f func(t1 T1, t2 T2, t3 T3) R1) func(v1 T1) func(v2 T2) func(v3 T3) R1 {
	return func(v1 T1) func(v2 T2) func(v3 T3) R1 {
		return func(v2 T2) func(v3 T3) R1 {
			return func(v3 T3) R1 {
				return f(v1, v2, v3)
			}
		}
	}
}

func add3(i int8, j int16, k int32) int64 {
	return int64(i) + int64(j) + int64(k)
}

func CurryingDemo() {
	c1 := PartialT3R1V1[int8, int16, int32, int64](add3, 5) // you have to manually pick your PartialTxRyVz function here
	fmt.Println(c1(6, 7))                                   // 18
	c2 := PartialT2R1V2(c1, 6, 7)                           // type arguments can be omitted
	fmt.Println(c2())                                       // 18
	f := CurryingT3R1(add3)                                 // currying
	fmt.Println(f(5)(6)(7))                                 // 18
}

// any is an alias for interface{} and is equivalent to interface{} in all ways.
type any = interface{}

// comparable is an interface that is implemented by all comparable types
// (booleans, numbers, strings, pointers, channels, interfaces,
// arrays of comparable types, structs whose fields are all comparable types).

package typed_set

import "fmt"

type Set[T comparable] struct {
	m map[T]bool
}

func (s *Set[T]) Add(value T) {
	if s.m == nil {
		s.m = map[T]bool{}
	}
	s.m[value] = true
}

func (s *Set[T]) List() []T {
	t := make([]T, 0, len(s.m))
	for i, v := range s.m {
		if v {
			t = append(t, i)
		}
	}
	return t
}

func TypedSetDemo() {
	s := Set[string]{}
	s.Add("1")
	s.Add("2")
	s.Add("1")
	s.Add("3")
	s.Add("4")
	l := s.List()
	for _, x := range l {
		fmt.Println(x)
	}
}

package define_constraints

import "fmt"

type MustSigned interface {
	int | int8 | int16 | int32 | int64
}

type UnderlyingMustSigned interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64
}

type SomeEnum int64

const (
	SomeEnum_ONE SomeEnum = 1
	SomeEnum_TWO SomeEnum = 2
)

func MustOne[T MustSigned](v T) bool {
	return v == 1
}

func UnderlyingMustTwo[T UnderlyingMustSigned](v T) bool {
	return v == 2
}

func DefineConstraintsDemo() {
	fmt.Println(MustOne(SomeEnum_ONE))
	fmt.Println(UnderlyingMustTwo(SomeEnum_TWO))
}

package min_comparable_interface

import (
	"constraints"
	"fmt"
	"time"
)

type ordered interface {
	Less(other ordered) bool
}

type Ordered interface {
	constraints.Ordered | ordered
}

func MinT[T Ordered](v ...T) T {
	var minT = v[0]
	for _, x := range v {
		if ox, ok := x.(ordered); ok { // although Go generics uses a syntax which looks like interface, it is actually not
			if ox.Less(minT.(ordered)) {
				minT = x
			}
		} else {
			if x < minT {
				minT = x
			}
		}
	}
	return minT
}

type OrderedTime struct {
	t time.Time
}

func (d *OrderedTime) Less(other *OrderedTime) bool {
	return d.t.Before(other.t)
}

func (d *OrderedTime) Time() time.Time {
	return d.t
}

func MinTest() {
	var O1 = []int64{9, 8, 7, 6, 1, 2, 3, 4, 5}
	fmt.Println(MinT(O1...))

	var O2 = []*OrderedTime{
		{
			t: time.Date(2022, 1, 20, 0, 0, 0, 0, time.UTC),
		},
		{
			t: time.Date(2022, 1, 10, 0, 0, 0, 0, time.UTC),
		},
		{
			t: time.Date(2022, 1, 30, 0, 0, 0, 0, time.UTC),
		},
	}
	fmt.Println(MinT(O2...).Time())
}

package iterator

import "fmt"

type Iterator[T any] interface {
	Value() T
	Next() Iterator[T]
}

type ST[T any] []T

type sliceIterator[T any] struct {
	s   ST[T]
	pos int
}

func (i *sliceIterator[T]) Value() T {
	return i.s[i.pos]
}

func (i *sliceIterator[T]) Next() Iterator[T] {
	if i.pos+1 < len(i.s) {
		return &sliceIterator[T]{
			pos: i.pos + 1,
			s:   i.s,
		}
	}
	return nil
}

func (s ST[T]) ToIterator() Iterator[T] {
	return &sliceIterator[T]{
		pos: 0,
		s:   s,
	}
}

func ToSlice[T any](i Iterator[T]) []T {
	var t []T
	for v := i; v != nil; v = v.Next() {
		t = append(t, v.Value())
	}
	return t
}

func IteratorDemo() {
	d := []int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	st := ST[int64](d)
	i := st.ToIterator()
	fmt.Println(ToSlice(i)) // [1 2 3 4 5 6 7 8 9 10]
}

package future

import (
	"fmt"
	"golang.org/x/sync/errgroup"
	"runtime"
	"sync"
	"time"
)

type Task[T any] struct {
	sync.RWMutex
	f      func() T
	done   bool
	result T
}

func (t *Task[T]) Start() {
	go func(self *Task[T]) {
		r := self.f()
		self.Lock()
		self.result = r
		self.done = true
		self.Unlock()
	}(t)
}

func (t *Task[T]) Done() bool {
	t.RLock()
	defer t.RUnlock()
	return t.done
}

func (t *Task[T]) Await() T {
	for {
		t.RLock()
		if t.done {
			t.RUnlock()
			return t.result
		}
		t.RUnlock()
		runtime.Gosched()
	}
}

func NewTask[T any](f func() T) *Task[T] {
	return &Task[T]{
		f: f,
	}
}

// All quite limited implementation of Javascript Promise.All or C# Task.WaitAll
func All[T any](f ...func() T) *Task[[]T] {
	resp := NewTask(func() []T { // NewTask[[]T]()
		r := make([]T, len(f))
		var eg errgroup.Group
		for index, task := range f {
			indexClosure := index
			taskClosure := task
			eg.Go(func() error {
				r[indexClosure] = taskClosure()
				return nil
			})
		}
		_ = eg.Wait()
		return r
	})
	return resp
}

func TaskTest() {
	t := NewTask(func() int64 {
		time.Sleep(3 * time.Second)
		return 10
	})
	t.Start()
	fmt.Println(t.Done()) // false
	time.Sleep(time.Second)
	fmt.Println(t.Done()) // false
	r := t.Await()
	fmt.Println(t.Done()) // true
	fmt.Println(r + 3)    // 13

	all := All(func() int64 {
		time.Sleep(3 * time.Second)
		return 3
	}, func() int64 {
		time.Sleep(4 * time.Second)
		return 4
	}, func() int64 {
		time.Sleep(5 * time.Second)
		return 5
	})
	all.Start()
	fmt.Println(all.Await()) // [3 4 5]
}

package typed_gorm

import (
	"fmt"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
)

type TypedGormDB[T any] struct {
	db *gorm.DB
}

func NewTypedGormDB[T any](txIn *gorm.DB) *TypedGormDB[T] {
	var tm T
	return &TypedGormDB[T]{
		db: txIn.Model(tm),
	}
}

// First simplified and typed implementation of (*gorm.DB).First
func (t *TypedGormDB[T]) First(dest *T) *TypedGormDB[T] {
	t.db = t.db.First(dest)
	return t
}

// Find simplified and typed implementation of (*gorm.DB).Find
func (t *TypedGormDB[T]) Find(dest *[]*T) *TypedGormDB[T] {
	t.db = t.db.Find(dest)
	return t
}

// Where simplified implementation of (*gorm.DB).Where
// however binding conditions to query would require Dependent Type support in the language
func (t *TypedGormDB[T]) Where(query string, conds ...any) *TypedGormDB[T] {
	t.db = t.db.Where(query, conds...)
	return t
}

// Create typed (*gorm.DB).Create
func (t *TypedGormDB[T]) Create(v *T) *TypedGormDB[T] {
	t.db = t.db.Create(v)
	return t
}

// Error return (*gorm.DB).Error
func (t *TypedGormDB[T]) Error() error {
	return t.db.Error
}

// AutoMigrate just for creating table in memory sqlite database
func (t *TypedGormDB[T]) AutoMigrate() error {
	var tm T
	return t.db.AutoMigrate(tm)
}

type Model struct {
	Id   uint64 `gorm:"column:id"`
	Name string `gorm:"column:name"`
}

func (Model) TableName() string {
	return "model"
}

func TypedGormDemo() {
	db, e0 := gorm.Open(sqlite.Open("file::memory:?cache=shared"), &gorm.Config{})
	if e0 != nil {
		panic(e0)
	}

	var result []*Model
	td := NewTypedGormDB[Model](db)

	if e1 := td.AutoMigrate(); e1 != nil {
		panic(e1)
	}

	m := []*Model{
		{
			Id:   1,
			Name: "test1",
		},
		{
			Id:   2,
			Name: "test2",
		},
		{
			Id:   3,
			Name: "test3",
		},
	}
	for _, mi := range m {
		td.Create(mi)
	}

	if e2 := td.Where("id in (?)", []int64{2, 3}).Find(&result).Error(); e2 != nil {
		panic(e2)
	}

	fmt.Println(result[0].Name, result[1].Name) // test2 test3
}

package functional_common

import "fmt"

func Map[T1, T2 any](s []T1, f func(T1) T2) []T2 {
	r := make([]T2, len(s))
	for i, v := range s {
		r[i] = f(v)
	}
	return r
}

func Reduce[T1, T2 any](s []T1, initializer T2, f func(T2, T1) T2) T2 {
	r := initializer
	for _, v := range s {
		r = f(r, v)
	}
	return r
}

func Filter[T any](s []T, f func(T) bool) []T {
	var r []T
	for _, v := range s {
		if f(v) {
			r = append(r, v)
		}
	}
	return r
}

func FunctionalCommonDemo() {
	fmt.Println(Reduce(Map(Filter([]int32{1, 2, 3, 4, 5}, func(t int32) bool {
		return t < 4 // [1, 2, 3]
	}), func(t int32) int64 {
		return int64(t) + 1 // [2, 3, 4]
	}), int64(0), func(t1, t2 int64) int64 {
		return t1 + t2 // 2 + 3 == 5; 5 + 4 = 9
	})) // 9
}

package reflection

import (
	"fmt"
	"reflect"
)

func PrintTypeOf[T1, T2 any](v1 T1, v2 T2) {
	fmt.Printf("%T %T %v\n", v1, v2, reflect.TypeOf(v1) == reflect.TypeOf(v2))
}

func ReflectionDemo() {
	a := []int64{1, 2, 3}
	b := []int32{4, 5}
	c := []int64{6}
	PrintTypeOf(a, b) // []int64 []int32 false
	PrintTypeOf(a, c) // []int64 []int64 true
}

package performance

func Add3Int32(s []int32) []int32 {
	for index := range s {
		s[index] += 3
	}
	return s
}

func Add3Int64(s []int64) []int64 {
	for index := range s {
		s[index] += 3
	}
	return s
}

package performance

func Add3Interface(s interface{}) interface{} {
	if sint64, ok := s.([]int64); ok {
		return Add3Int64(sint64)
	}
	if sint32, ok := s.([]int32); ok {
		return Add3Int32(sint32)
	}
	if sinterface, ok := s.([]interface{}); ok {
		return Add3InterfaceSlice(sinterface)
	}
	panic("unsupported slice type")
}

func Add3InterfaceSlice(s []interface{}) []interface{} {
	for index, value := range s {
		switch vi := value.(type) {
		case int32:
			{
				s[index] = vi + 3
			}
		case int64:
			{
				s[index] = vi + 3
			}
		default:
			{
				panic("unsupported slice element type")
			}
		}
	}
	return s
}

package performance

type SupportedIntegers interface {
	~int64 | ~int32
}

func Add3Generics[T SupportedIntegers](s []T) []T {
	for index := range s {
		s[index] += 3
	}
	return s
}

package performance

import (
	"testing"
)

func BenchmarkBaseline(t *testing.B) {
	// baseline
	si32 := []int32{1, 2, 3}
	si64 := []int64{4, 5, 6}
	for i := 0; i < t.N; i++ {
		Add3Int32(si32)
		Add3Int64(si64)
	}
}

func BenchmarkInterface(t *testing.B) {
	// using interface
	si32 := []int32{1, 2, 3}
	si64 := []int64{4, 5, 6}
	for i := 0; i < t.N; i++ {
		Add3Interface(si32)
		Add3Interface(si64)
	}
}

func BenchmarkSliceInterface(t *testing.B) {
	// using slice of interface
	sinterface1 := []interface{}{int32(1), int32(2), int64(3)}
	sinterface2 := []interface{}{int64(4), int64(5), int64(6)}
	for i := 0; i < t.N; i++ {
		Add3InterfaceSlice(sinterface1)
		Add3InterfaceSlice(sinterface2)
	}
}

func BenchmarkGenerics(t *testing.B) {
	// using generics
	si32 := []int32{1, 2, 3}
	si64 := []int64{4, 5, 6}
	for i := 0; i < t.N; i++ {
		Add3Generics(si32)
		Add3Generics(si64)
	}
}