/*
 filter --- Simple interactive data filter for POSIX pipelines

Copyright (c) 2022  Sameer Rahmani <lxsameer@gnu.org>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

package main

import (
	"fmt"
	"log"
	"strings"

	"github.com/gdamore/tcell/v2"
)

// TODO: Use tcell/v2/views instead of a manual scrolling computation

// TODO: Right now, filter does not handle terminal resize properly,
//fix it!

// Screen size
var xmax int
var ymax int

// TODO: Make the highlight style configuratble.
// The style to be used with the current line
var highlight,
	selectedStyle,
	helpStyle,
	selectionStyle,
	selectionArrow,
	cursorStyle,
	normalArrow tcell.Style

var help [][]string = [][]string{
	{"?", "View help"},
	{"TAB", "Select an entry"},
	{"C-p, Up", "Move up"},
	{"C-n, Down", "Move down"},
	{"C-space", "Start/Stop muliple-selection"},
	{"C-e, End", "Jump to the end of input"},
	{"C-e, End", "Jump to the end of input"},
	{"q", "Back"},
	{"ESC", "Exit"},
}

type Scene struct {
	RenderFn     func(*State, Items)
	KeyHandlerFn func(*State, tcell.EventKey, Items)
}

type State struct {
	Current            int
	InSelectionMode    bool
	SelectionStartLine int
	UpperBound         int
	LowerBound         int
	Screen             *tcell.Screen
	Scenes             []*Scene
	CurrentScene       int
	UserInput          string
}

// Draws the given `text` to the screen `s` at the given coordinates. Remember that
// the text will be wrapped if it overflow.
func drawText(s tcell.Screen, x1, y1, x2, y2 int, style tcell.Style, text string) {
	row := y1
	col := x1
	for _, r := range text {
		s.SetContent(col, row, r, nil, style)
		col++
		if col >= x2 {
			row++
			col = x1
		}
		if row > y2 {
			break
		}
	}
}

// Main render function that gets called during the event loop.
func Render(s *State, inputs Items) {
	scene := s.Scenes[s.CurrentScene]
	scene.RenderFn(s, inputs)
}

func RenderHelp(s *State, inputs Items) {
	y := 2
	for _, key := range help {
		drawText(*s.Screen, 4, y, 25, y+1, tcell.StyleDefault.Bold(true), key[0])
		drawText(*s.Screen, 25, y, xmax-1, y+1, tcell.StyleDefault.Bold(true), key[1])
		y += 1
	}

}

func RenderMain(s *State, inputs Items) {
	y := 2
	status := fmt.Sprintf("[Line: %d][? For help]", s.Current+1)
	//status := fmt.Sprintf("[Line: %d][? For help]: %s", s.Current+1, s.UserInput)
	//status := fmt.Sprintf("L: %d, U: %d, S: %d [Line: %d][? For help]: %s", s.LowerBound, s.UpperBound, s.SelectionStartLine, s.Current+1, s.UserInput)
	drawText(*s.Screen, 0, 0, xmax-1, 1, helpStyle, status)
	//drawText(*s.Screen, len(status), 0, xmax-1, 1, cursorStyle, "⎥")

	for i, item := range (*inputs)[s.LowerBound:s.UpperBound] {
		style := tcell.StyleDefault
		arrowStyle := normalArrow
		index := s.LowerBound + i

		var txt string

		if item.Selected {
			txt = fmt.Sprintf("  X %s", item.Text)
			style = selectedStyle
		} else {
			txt = fmt.Sprintf("    %s", item.Text)
		}

		if s.Current == s.LowerBound+i {
			style = highlight
		}

		if s.InSelectionMode {
			if (s.SelectionStartLine < s.LowerBound && index <= s.Current) || (s.SelectionStartLine > s.UpperBound && index >= s.Current) {
				style = selectionStyle
				arrowStyle = selectionArrow
			} else {
				low := min(s.SelectionStartLine, s.Current)
				high := max(s.SelectionStartLine, s.Current)

				if index >= low && index <= high {
					style = selectionStyle
					arrowStyle = selectionArrow
				}
			}
		}

		drawText(*s.Screen, 0, y, len(txt), y+1, style, txt)
		// Clean up the rest of the line that might've been filled with a previous render.
		// This is a hack to NOT use `Clear` on each loop
		drawText(*s.Screen, len(txt), y, xmax-1, y+1, style, strings.Repeat(" ", xmax-len(txt)))

		if s.Current == s.LowerBound+i {
			drawText(*s.Screen, 0, y, 1, y+1, arrowStyle, ">")
		}

		y += 1
	}

}

func HandleKeyEvents(s *State, ev tcell.EventKey, inputs Items) {
	scene := s.Scenes[s.CurrentScene]
	scene.KeyHandlerFn(s, ev, inputs)
}

func HandleMain(state *State, ev tcell.EventKey, input Items) {
	if ev.Key() == tcell.KeyTAB {
		// Mark the current line as selected
		if state.InSelectionMode {
			start := min(state.SelectionStartLine, state.Current)
			end := max(state.SelectionStartLine, state.Current)
			toggleItems(input, start, end+1)
			state.SelectionStartLine = -1
			state.InSelectionMode = false
		} else {
			item := (*input)[state.Current]
			item.Selected = !item.Selected
		}

	} else if ev.Key() == tcell.KeyUp || ev.Key() == tcell.KeyCtrlP {
		if state.Current > 0 {
			state.Current -= 1
		}
		if state.Current <= state.LowerBound && state.Current != 0 {
			state.LowerBound -= 1
			state.UpperBound -= 1
		}

	} else if ev.Key() == tcell.KeyDown || ev.Key() == tcell.KeyCtrlN {
		if state.Current < len(*input)-1 {
			state.Current += 1
		}

		if state.Current >= state.UpperBound && state.Current != len(*input)-1 {
			state.LowerBound += 1
			state.UpperBound += 1
		}
	} else if ev.Key() == tcell.KeyCtrlE || ev.Key() == tcell.KeyEnd {
		state.UpperBound = len(*input)
		state.LowerBound = state.UpperBound - ymax + 2
		state.Current = len(*input) - 1

	} else if ev.Key() == tcell.KeyCtrlA || ev.Key() == tcell.KeyHome {
		state.UpperBound = ymax - 2
		state.LowerBound = 0
		state.Current = 0

	} else if ev.Key() == tcell.KeyCtrlSpace {
		if state.InSelectionMode {
			state.SelectionStartLine = -1
		} else {
			state.SelectionStartLine = state.Current
		}

		state.InSelectionMode = !state.InSelectionMode

	} else if ev.Rune() == '?' {
		state.CurrentScene = 1
	} else if ev.Key() == tcell.KeyBackspace || ev.Key() == tcell.KeyBackspace2 {
		if len(state.UserInput) != 0 {
			state.UserInput = string(state.UserInput[:len(state.UserInput)-1])
		}

	} else {
		state.UserInput = state.UserInput + string(ev.Rune())
	}
}

func HandleHelp(state *State, ev tcell.EventKey, input Items) {
	if ev.Rune() == 'q' {
		state.CurrentScene = 0
	}
}

func main() {
	input, err := ReadFromStdin()
	if err != nil {
		log.Fatalf("%+v", err)
	}

	// TODO: Make the default style configurable
	defStyle := tcell.StyleDefault.Background(tcell.ColorDefault).Foreground(tcell.ColorDefault)
	highlight = tcell.StyleDefault.Background(tcell.ColorDefault).Foreground(tcell.ColorDefault).Bold(true)
	selectedStyle = tcell.StyleDefault.Foreground(tcell.ColorPlum)
	helpStyle = tcell.StyleDefault.Foreground(tcell.ColorDefault)
	selectionStyle = tcell.StyleDefault.Background(tcell.ColorRebeccaPurple).Foreground(tcell.ColorDefault)
	selectionArrow = tcell.StyleDefault.Background(tcell.ColorRebeccaPurple).Foreground(tcell.ColorGreen).Bold(true)
	normalArrow = tcell.StyleDefault.Foreground(tcell.ColorGreen).Bold(true)
	cursorStyle = normalArrow.Blink(true)

	done := false

	// Initialize screen
	tty, err := tcell.NewDevTty()
	if err != nil {
		log.Fatalf("%+v", err)
	}

	s, err := tcell.NewTerminfoScreenFromTty(tty)
	if err != nil {
		log.Fatalf("%+v", err)
	}
	if err := s.Init(); err != nil {
		log.Fatalf("%+v", err)
	}
	s.SetStyle(defStyle)
	s.Clear()
	xmax, ymax = s.Size()

	quit := func() {
		// You have to catch panics in a defer, clean up, and
		// re-raise them - otherwise your application can
		// die without leaving any diagnostic trace.
		maybePanic := recover()
		s.Fini()
		if maybePanic != nil {
			panic(maybePanic)
		}
	}
	defer quit()

	mainScene := Scene{
		RenderMain,
		HandleMain,
	}
	helpScene := Scene{
		RenderHelp,
		HandleHelp,
	}

	state := State{
		Current:            0,
		SelectionStartLine: 0,
		Screen:             &s,
		LowerBound:         0,
		UpperBound:         min(ymax-3, len(*input)),
		InSelectionMode:    false,
		CurrentScene:       0,
		Scenes:             []*Scene{&mainScene, &helpScene},
	}

	previousScene := 0

	// Event loop
	for !done {
		// If we need to render a new scene let's clear the screen first
		if state.CurrentScene != previousScene {
			s := *state.Screen
			s.Clear()
		}

		Render(&state, input)

		// Update screen
		s.Show()

		// Poll event
		ev := s.PollEvent()

		// Process event
		switch ev := ev.(type) {
		case *tcell.EventResize:
			s.Sync()
		case *tcell.EventKey:
			if ev.Key() == tcell.KeyEscape || ev.Key() == tcell.KeyCtrlC {
				return
			} else if ev.Key() == tcell.KeyEnter {
				done = true
				break
			} else if ev.Key() == tcell.KeyCtrlL {
				s.Sync()
			} else {
				// In case of no global binding hand the even to the scene
				HandleKeyEvents(&state, *ev, input)
			}
		}
	}

	// Deinitialize the screen so we can use the stdout properly
	s.Fini()

	// Write what ever that got selected to the stdout
	for _, item := range *input {
		if item.Selected {
			fmt.Println(item.Text)
		}
	}

}