package routes

import (
	"embed"
	"html/template"
	"log"
	"math"
	"net/http"
	"slices"

	"sunshine.industries/some-automoderation/rooms"
)

type brickState struct {
	ColorClass   template.CSS
	TemplateType string
}
type personData struct {
	Name      string
	IsSpeaker bool
	IsMark    bool
	IsRaised  bool
	Raised    rooms.HandGesture
	Mark      rooms.HandGesture
	Index     int
}

var brickColors = map[rooms.HandGesture]template.CSS{
	rooms.Meta:        "--meta-color",
	rooms.ClarifyingQ: "--clarifying-q-color",
	rooms.Expand:      "--expand-color",
	rooms.ProbingQ:    "--probing-q-color",
	rooms.ChangeTopic: "--change-topic-color",
}

// data to be passed to "roomPeople" template
type roomTableData struct {
	*rooms.Room
	currentPerson rooms.PersonId
}

func (room *roomTableData)Persons() []personData {
	total := room.Total()
	persons := make([]personData, 0, total)
	currentPersonIndex := slices.Index(room.Paricipants, room.currentPerson)
	for i, pId := range room.Paricipants {
		personData := personDataFromRoom(room, pId)
		// to have index 0 for 'current person'
		personData.Index = (i - currentPersonIndex + total) % total
		persons = append(persons, personData)
	}
	return persons
}
func (r *roomTableData)Total() int {
	return len(r.Paricipants)
}
func (r *roomTableData)Tangens() float64 {
	total := r.Total()
	if total == 2 {
		return 1
	}
	return math.Tan(math.Pi / float64(r.Total())) // Math.tan(Math.PI/m);
}

func personDataFromRoom(room *roomTableData, pId rooms.PersonId) personData {
	person, exists := room.AllKnownPeople[pId]
	if !exists || !slices.Contains(room.Paricipants, pId) {
		return personData{}
	}

	hand, handExists := room.ParticipantHands[pId]
	var mark rooms.HandGesture
	var markExists bool
	for gesture := rooms.ChangeTopic; gesture <= rooms.Meta; gesture++ {
		if room.Marks[gesture] == pId {
			markExists = true
			mark = gesture
		}
	}
	isSpeaker := room.CurrentSpeaker == pId

	return personData{
		Name:      person.Name,
		IsSpeaker: isSpeaker,
		IsRaised:  handExists,
		Raised:    hand,
		IsMark:    markExists,
		Mark:      mark,
	}
}

func (pData personData)BricksForPerson() []brickState {
	var result = make([]brickState, 5)
	for gesture := rooms.ChangeTopic; gesture <= rooms.Meta; gesture++ {
		// for index := rooms.Meta; index >= rooms.ChangeTopic; index-- {
		// log.Printf(">>>>> iteraging for %d", gesture)
		// this results in iteration 4,3,2,1,0,255 wow
		templateType := "inactiveBrick"
		switch {
		case pData.IsMark && gesture == pData.Mark:
			templateType = "markBrick"
		case pData.IsSpeaker && gesture == pData.Raised:
			templateType = "speakerBrick"
		case pData.IsRaised && gesture == pData.Raised:
			templateType = "raisedBrick"
		}

		result[gesture] = brickState{
			ColorClass:   brickColors[gesture],
			TemplateType: templateType,
		}
	}

	slices.Reverse(result)
	return result
}

func roomTemplatesPreview(
	templateFs *embed.FS,
) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {

		type SingleBrickData struct {
			ColorClass template.CSS
			Name       string
		}

		testPersonData := personData{
			Name:     "John Doe",
			IsRaised: true,
			Raised:   rooms.Expand,
			IsMark:   true,
			Mark:     rooms.ProbingQ,
		}

		var person1 = rooms.Person{
			Id:   rooms.PersonId(100),
			Name: "test person 1",
		}
		var person2 = rooms.Person{
			Id:   rooms.PersonId(200),
			Name: "test person 2",
		}
		var person3 = rooms.Person{
			Id:   rooms.PersonId(300),
			Name: "test person 3",
		}
		aRoom := rooms.Room{
			Name:           "test",
			CurrentSpeaker: person3.Id,
			AllKnownPeople: map[rooms.PersonId]rooms.Person{
				person1.Id: person1,
				person2.Id: person2,
				person3.Id: person3,
			},
			Paricipants: []rooms.PersonId{
				person1.Id,
				person2.Id,
				person3.Id,
			},
			ParticipantHands: map[rooms.PersonId]rooms.HandGesture{
				person3.Id: rooms.ClarifyingQ,
				person2.Id: rooms.Meta,
			},
			Marks: map[rooms.HandGesture]rooms.PersonId{
				rooms.Expand: person1.Id,
			},
		}

		contentData := struct {
			DefaultColor template.CSS
			Bricks       []SingleBrickData
			ABrick       brickState
			TestPerson   personData
			ARoom        *roomTableData
		}{
			DefaultColor: "--expand-color",
			ABrick: brickState{
				ColorClass:   "--expand-color",
				TemplateType: "raisedBrick",
			},
			Bricks: []SingleBrickData{
				{
					Name:       "expand",
					ColorClass: brickColors[rooms.Expand],
				},
				{
					Name:       "probing question",
					ColorClass: brickColors[rooms.ProbingQ],
				},
				{
					Name:       "change topic",
					ColorClass: brickColors[rooms.ChangeTopic],
				},
				{
					Name:       "clarifying question",
					ColorClass: brickColors[rooms.ClarifyingQ],
				},
				{
					Name:       "meta",
					ColorClass: brickColors[rooms.Meta],
				},
			},
			TestPerson: testPersonData,
			ARoom:      &roomTableData{
				Room: &aRoom,
				currentPerson: aRoom.Paricipants[0],
			},
		}

		pageData := pageData{
			Header:  headerData{Title: "look at the room templates"},
			Content: contentData,
		}

		baseFile := "templates/base.gohtml"
		tmpl := template.Must(template.New("").ParseFS(templateFs, baseFile,
			"templates/tableTemplates.gohtml",
			"templates/tableTemplatesPreview.gohtml",
		))

		err := tmpl.ExecuteTemplate(w, "full-page", pageData)
		if err != nil {
			log.Printf("yoyo, error %s", err)
		}

	}
}