package pingo

import (
	"strings"
	"testing"

	tea "charm.land/bubbletea/v2"
	"github.com/stretchr/testify/assert"
)

func spawnTestModel(addresses []string, points []float64, width, height, cHeight int) Model {
	testModel := InitialModel(addresses, cHeight, width, height)
	for i := range testModel.Addresses {
		testModel.Addresses[i].Results = points
	}

	return testModel
}

func Test_InitialModel(t *testing.T) {
	addresses := []string{"127.0.0.1", "cantresolvethisever"}
	chartHeight := 10
	model := InitialModel(addresses, 80, 24, chartHeight)

	assert.Implements(t, new(tea.Model), model)

	assert.Equal(t, chartHeight, model.ChartHeight)
	assert.Equal(t, 80, model.Width)
	assert.Equal(t, 24, model.Height)
	assert.Equal(t, 2, len(model.Addresses))
	for i, address := range model.Addresses {
		assert.Equal(t, 80, address.MaxResults)
		assert.Equal(t, addresses[i], address.Address)
	}
}

func Test_Model_Update_handle_pollMsg(t *testing.T) {
	testModel := spawnTestModel(
		[]string{"127.0.0.1"}, []float64{}, 0, 20, 10)
	batch := testModel.Poll()
	msg := batch().(pollResultMsg)
	assert.IsType(t, *new(pollResultMsg), msg)
	assert.Equal(t, 1, len(msg.results))
	assert.InDelta(t, 1, msg.results[0], 10)
	assert.Nil(t, msg.err)
	assert.Equal(t, 0, msg.index)

	model, batch := testModel.Update(msg)
	assert.IsType(t, *new(tea.Cmd), batch)
	assert.Equal(t, msg.results, model.(Model).Addresses[0].Results)
}

func Test_Model_View(t *testing.T) {
	testModel := spawnTestModel(
		[]string{"127.0.0.1", "cantresolvethisever"}, []float64{1.0, 2.0, 3.0}, 20, 20, 10)
	result := testModel.View()
	assert.IsType(t, *new(tea.View), result)
}

func Test_Model_View_init_state(t *testing.T) {
	testModel := spawnTestModel(
		[]string{"127.0.0.1", "cantresolvethisever"}, []float64{}, 0, 20, 10)
	result := testModel.View().Content
	assert.IsType(t, *new(string), result)

	assert.True(t, strings.Contains(result, "127.0.0.1"))
	assert.True(t, strings.Contains(result, "cantresolvethisever"))
	assert.False(t, strings.Contains(result, "pingo"))
	assert.False(t, strings.Contains(result, "j/k: up/down"))
	for line := range strings.SplitSeq(result, "\n") {
		if strings.Contains(line, "127.0.0.1") || strings.Contains(line, "cantresolvethisever") {
			assert.True(t, strings.Contains(line, "loading..."))
		}
	}
}

func Test_Model_View_connection_unstable(t *testing.T) {
	testModel := spawnTestModel([]string{"doesntmatter"}, []float64{-1}, 200, 200, 200)

	result := testModel.View().Content
	assert.IsType(t, *new(string), result)
	assert.True(t, strings.Contains(result, "connection unstable"), result)
}

func Test_Model_View_has_charts(t *testing.T) {
	testModel := spawnTestModel(
		[]string{"127.0.0.1", "cantresolvethisever"}, make([]float64, 20), 200, 200, 200)
	result := testModel.View().Content
	assert.IsType(t, *new(string), result)

	assert.True(t, strings.Contains(result, "127.0.0.1"))
	assert.True(t, strings.Contains(result, "cantresolvethisever"))
	assert.False(t, strings.Contains(result, "pingo"))
	assert.False(t, strings.Contains(result, "j/k: up/down"))
	lines := strings.Split(result, "\n")
	for i, line := range lines {
		if strings.Contains(line, "127.0.0.1") || strings.Contains(line, "cantresolvethisever") {
			assert.False(t, strings.Contains(line, "loading..."))
			assert.True(t, strings.Contains(lines[i+1], "│")) // assert has chart seperator character
		}
	}
}

func Test_Model_View_has_big_chart(t *testing.T) {
	testModel := spawnTestModel(
		[]string{"127.0.0.1"}, make([]float64, 20), 20, 20, 200)
	result := testModel.View().Content
	assert.IsType(t, *new(string), result)
	assert.IsType(t, *new(string), result)

	assert.True(t, strings.Contains(result, "127.0.0.1"))
	assert.True(t, strings.Contains(result, "127.0.0.1"), result)

	lines := strings.Split(result, "\n")
	assert.True(t, strings.Contains(lines[1], "127.0.0.1"), lines[1])
	assert.False(t, strings.Contains(lines[1], "loading..."))
	assert.True(t, strings.Contains(lines[21], "0│"), result)
}

func Test_Model_View_has_big_charts(t *testing.T) {
	testModel := spawnTestModel(
		[]string{"127.0.0.1", "cantresolvethisever"}, make([]float64, 20), 20, 20, 200)
	result := testModel.View().Content
	assert.IsType(t, *new(string), result)

	assert.True(t, strings.Contains(result, "127.0.0.1"))
	assert.True(t, strings.Contains(result, "cantresolvethisever"))
	assert.False(t, strings.Contains(result, "pingo"))
	assert.False(t, strings.Contains(result, "j/k: up/down"))
	lines := strings.Split(result, "\n")
	for i, line := range lines {
		if strings.Contains(line, "127.0.0.1") || strings.Contains(line, "cantresolvethisever") {
			assert.False(t, strings.Contains(line, "loading..."))
			assert.True(t, strings.Contains(lines[i+20], "0│"), lines[i+20]) // assert bottom of chart is where we expect it to be
		}
	}
}

func Test_Model_cmd_Poll(t *testing.T) {
	addresses := []string{"127.0.0.1", "cantresolvethisever"}
	chartHeight := 10
	model := InitialModel(addresses, chartHeight, 80, 24)
	batch := model.Poll()
	msgs := []tea.Cmd(batch().(tea.BatchMsg)) // type assert for legibility
	for i, cmd := range msgs {
		msg := cmd()
		assert.IsType(t, *new(pollResultMsg), msg)
		result := msg.(pollResultMsg)
		switch i {
		case 0:
			assert.Equal(t, 1, len(result.results))
			assert.InDelta(t, 1, result.results[0], 10)
			assert.Nil(t, result.err)
			assert.Equal(t, 0, result.index)
		case 1:
			assert.Equal(t, 1, len(result.results))
			assert.Equal(t, float64(-1), result.results[0])
			assert.NotNil(t, result.err.Error())
			assert.Equal(t, 1, result.index)
		}
	}
}