package main

import "fmt"

const cueTrackID = "_cue"

type Show struct {
	Tracks   []*Track   `json:"tracks"`
	Blocks   []*Block   `json:"blocks"`
	Triggers []*Trigger `json:"triggers"`
}

type Track struct {
	ID   string `json:"id"`
	Name string `json:"name"`
}

type Block struct {
	ID    string `json:"id"`
	Type  string `json:"type"`
	Track string `json:"track,omitempty"`
	Name  string `json:"name"`
	Loop  bool   `json:"loop,omitempty"`
}

type Trigger struct {
	Source  TriggerSource   `json:"source"`
	Targets []TriggerTarget `json:"targets"`
}

type TriggerSource struct {
	Block  string `json:"block"`
	Signal string `json:"signal"`
}

type TriggerTarget struct {
	Block string `json:"block"`
	Hook  string `json:"hook"`
}

type TimelineTrack struct {
	*Track
	Cells []*TimelineCell `json:"cells"`
}

type Timeline struct {
	Tracks []*TimelineTrack   `json:"tracks"`
	Blocks map[string]*Block  `json:"blocks"`

	show        *Show                      `json:"-"`
	trackIdx    map[string]*TimelineTrack  `json:"-"`
	constraints []constraint               `json:"-"`
	exclusives  []exclusiveGroup           `json:"-"`
}

type TimelineCell struct {
	BlockID  string `json:"block_id,omitempty"`
	IsStart  bool   `json:"is_start,omitempty"`
	IsEnd    bool   `json:"is_end,omitempty"`
	Event    string `json:"event,omitempty"`
	IsTitle  bool   `json:"is_title,omitempty"`
	IsSignal bool   `json:"is_signal,omitempty"`
	IsGap    bool   `json:"-"`
	IsBreak  bool   `json:"-"`
	row      int              `json:"-"`
	track    *TimelineTrack   `json:"-"`
}

type constraint struct {
	kind string
	a    *TimelineCell
	b    *TimelineCell
}

type exclusiveGroup struct {
	members []*TimelineCell
}

func validateShow(show *Show) error {
	startTargeted := map[string]bool{}
	for _, trigger := range show.Triggers {
		for _, target := range trigger.Targets {
			if target.Hook == "START" {
				startTargeted[target.Block] = true
			}
		}
	}

	for _, block := range show.Blocks {
		if block.Type == "cue" {
			continue
		}
		if !startTargeted[block.ID] {
			return fmt.Errorf("block %q has no trigger for its START", block.ID)
		}
	}

	return nil
}

func BuildTimeline(show *Show) (Timeline, error) {
	if err := validateShow(show); err != nil {
		return Timeline{}, err
	}

	tl := Timeline{
		show:     show,
		Blocks:   map[string]*Block{},
		trackIdx: map[string]*TimelineTrack{},
	}

	cueTrack := &TimelineTrack{Track: &Track{ID: cueTrackID, Name: "Cue"}}
	tl.Tracks = append(tl.Tracks, cueTrack)
	tl.trackIdx[cueTrackID] = cueTrack
	for _, track := range show.Tracks {
		tt := &TimelineTrack{Track: track}
		tl.Tracks = append(tl.Tracks, tt)
		tl.trackIdx[track.ID] = tt
	}
	for _, block := range show.Blocks {
		if block.Type == "cue" {
			block.Track = cueTrackID
		}
		tl.Blocks[block.ID] = block
	}

	endChains := map[string]bool{}
	for _, trigger := range show.Triggers {
		if trigger.Source.Signal != "END" {
			continue
		}
		srcTrack := tl.Blocks[trigger.Source.Block].Track
		for _, target := range trigger.Targets {
			if target.Hook == "START" && tl.Blocks[target.Block].Track == srcTrack {
				endChains[trigger.Source.Block] = true
			}
		}
	}

	tl.buildCells(endChains)
	tl.buildConstraints()
	tl.assignRows()

	return tl, nil
}

func (tl *Timeline) addConstraint(kind string, a, b *TimelineCell) {
	tl.constraints = append(tl.constraints, constraint{kind: kind, a: a, b: b})
}

func (track *TimelineTrack) appendCells(cells ...*TimelineCell) {
	for _, c := range cells {
		c.row = len(track.Cells)
		c.track = track
		track.Cells = append(track.Cells, c)
	}
}

func getCueCells(block *Block) []*TimelineCell {
	return []*TimelineCell{{
		BlockID: block.ID,
		IsStart: true,
		IsEnd:   true,
		Event:   "GO",
	}}
}

func getBlockCells(block *Block) []*TimelineCell {
	return []*TimelineCell{
		{BlockID: block.ID, IsStart: true, Event: "START"},
		{BlockID: block.ID, IsTitle: true},
		{BlockID: block.ID, Event: "FADE_OUT"},
		{BlockID: block.ID, IsEnd: true, Event: "END"},
	}
}

func (tl *Timeline) findCell(blockID, event string) *TimelineCell {
	track := tl.trackIdx[tl.Blocks[blockID].Track]
	for _, c := range track.Cells {
		if !c.IsGap && c.BlockID == blockID && c.Event == event {
			return c
		}
	}
	panic("cell not found: " + blockID + " " + event)
}

func (tl *Timeline) buildCells(endChains map[string]bool) {
	lastOnTrack := map[string]*Block{}
	for _, block := range tl.show.Blocks {
		lastOnTrack[block.Track] = block
	}

	for _, block := range tl.show.Blocks {
		track := tl.trackIdx[block.Track]
		var cells []*TimelineCell
		switch block.Type {
		case "cue":
			cells = getCueCells(block)
		default:
			cells = getBlockCells(block)
		}
		track.appendCells(cells...)
		if block.Type != "cue" && !endChains[block.ID] && lastOnTrack[block.Track] != block {
			track.appendCells(&TimelineCell{IsGap: true, IsBreak: true})
		}
	}
}

func (tl *Timeline) buildConstraints() {
	for _, trigger := range tl.show.Triggers {
		source := tl.findCell(trigger.Source.Block, trigger.Source.Signal)

		group := exclusiveGroup{members: []*TimelineCell{source}}

		for _, target := range trigger.Targets {
			t := tl.findCell(target.Block, target.Hook)
			if source.track == t.track {
				tl.addConstraint("next_row", source, t)
			} else {
				tl.addConstraint("same_row", source, t)
				source.IsSignal = true
			}
			group.members = append(group.members, t)
		}
		tl.exclusives = append(tl.exclusives, group)
	}
}

func (tl *Timeline) assignRows() {
	for {
		if tl.enforceConstraints() {
			continue
		}
		if tl.enforceExclusives() {
			continue
		}
		break
	}
}

func (tl *Timeline) enforceConstraints() bool {
	for _, c := range tl.constraints {
		switch c.kind {
		case "same_row":
			if c.a.row < c.b.row {
				tl.insertGap(c.a.track, c.a.row)
				return true
			} else if c.b.row < c.a.row {
				tl.insertGap(c.b.track, c.b.row)
				return true
			}
		case "next_row":
			if c.b.row <= c.a.row {
				tl.insertGap(c.b.track, c.b.row)
				return true
			}
		}
	}
	return false
}

func (tl *Timeline) enforceExclusives() bool {
	for _, g := range tl.exclusives {
		row := g.members[0].row
		allAligned := true
		memberTracks := map[*TimelineTrack]bool{}
		for _, m := range g.members {
			memberTracks[m.track] = true
			if m.row != row {
				allAligned = false
			}
		}
		if !allAligned {
			continue
		}
		for _, t := range tl.Tracks {
			if memberTracks[t] {
				continue
			}
			if row >= len(t.Cells) {
				continue
			}
			c := t.Cells[row]
			if c.IsGap || c.BlockID == "" {
				continue
			}
			tl.insertGap(t, row)
			return true
		}
	}
	return false
}

func (tl *Timeline) isAllGapRow(row int, except *TimelineTrack) bool {
	for _, t := range tl.Tracks {
		if t == except {
			continue
		}
		if row >= len(t.Cells) {
			continue
		}
		if !t.Cells[row].IsGap {
			return false
		}
	}
	return true
}

func (tl *Timeline) removeGapAt(track *TimelineTrack, index int) {
	track.Cells = append(track.Cells[:index], track.Cells[index+1:]...)
	for i := index; i < len(track.Cells); i++ {
		track.Cells[i].row = i
	}
}

func (tl *Timeline) gapInsertionPoint(track *TimelineTrack, index int) int {
	for {
		blocked := false
		for _, c := range tl.constraints {
			if c.kind == "next_row" && c.a.track == track && c.b.track == track && c.a.row == index-1 && c.b.row == index {
				index = c.a.row
				blocked = true
				break
			}
		}
		if !blocked {
			return index
		}
	}
}

func (tl *Timeline) insertGap(track *TimelineTrack, beforeIndex int) {
	beforeIndex = tl.gapInsertionPoint(track, beforeIndex)

	if tl.isAllGapRow(beforeIndex, track) {
		for _, t := range tl.Tracks {
			if t == track {
				continue
			}
			if beforeIndex >= len(t.Cells) {
				continue
			}
			if t.Cells[beforeIndex].IsGap {
				tl.removeGapAt(t, beforeIndex)
			}
		}
		return
	}

	gap := &TimelineCell{IsGap: true, row: beforeIndex, track: track}
	for i := beforeIndex - 1; i >= 0; i-- {
		c := track.Cells[i]
		if c.IsGap {
			continue
		}
		if c.BlockID != "" && !c.IsEnd {
			gap.BlockID = c.BlockID
		}
		break
	}

	newCells := make([]*TimelineCell, 0, len(track.Cells)+1)
	newCells = append(newCells, track.Cells[:beforeIndex]...)
	newCells = append(newCells, gap)
	newCells = append(newCells, track.Cells[beforeIndex:]...)
	track.Cells = newCells
	for i := beforeIndex + 1; i < len(track.Cells); i++ {
		track.Cells[i].row = i
	}
}