package apps

import (
	"log"
	"testing"

	"github.com/jinzhu/gorm"
	"github.com/rosti-cz/node-api/detector"
	"github.com/stretchr/testify/assert"

	// This is line from GORM documentation that imports database dialect
	_ "github.com/jinzhu/gorm/dialects/sqlite"
)

const testDBPath = "file::memory:?cache=shared"

func testDB() *gorm.DB {
	db, err := gorm.Open("sqlite3", testDBPath)
	if err != nil {
		log.Fatalln(err)
	}

	return db
}

func TestAppsProcessorGet(t *testing.T) {
	processor := AppsProcessor{
		DB: testDB(),
	}
	processor.Init()

	err := processor.New("testapp_1234", 1000, 1001, "testimage", 2, 256)
	assert.Nil(t, err)

	app, err := processor.Get("testapp_1234")
	assert.Nil(t, err)
	assert.Greater(t, int(app.ID), 0)
}

func TestAppsProcessorList(t *testing.T) {
	processor := AppsProcessor{
		DB: testDB(),
	}
	processor.Init()

	err := processor.New("testapp_2234", 1002, 1003, "testimage", 2, 256)
	assert.Nil(t, err)

	apps, err := processor.List()
	assert.Nil(t, err)
	assert.Equal(t, "testapp_1234", apps[0].Name)
}

func TestAppsProcessorNew(t *testing.T) {
	processor := AppsProcessor{
		DB: testDB(),
	}
	processor.Init()

	err := processor.New("testapp_1234", 1002, 1003, "testimage", 2, 256)
	assert.Nil(t, err)
}

func TestAppsProcessorUpdate(t *testing.T) {
	processor := AppsProcessor{
		DB: testDB(),
	}
	processor.Init()

	err := processor.New("updateapp_1224", 1002, 1003, "testimage", 2, 256)
	assert.Nil(t, err)

	env := make(map[string]string)
	env["TEST"] = "test"

	_, err = processor.Update("updateapp_1224", 1052, 1053, "testimage2", 4, 512, env)
	assert.Nil(t, err)

	app, err := processor.Get("updateapp_1224")
	assert.Nil(t, err)

	assert.Equal(t, 1052, app.SSHPort)
	assert.Equal(t, 1053, app.HTTPPort)
	assert.Equal(t, "testimage2", app.Image)
	assert.Equal(t, 4, app.CPU)
	assert.Equal(t, 512, app.Memory)
}

func TestAppsProcessorUpdateResources(t *testing.T) {
	processor := AppsProcessor{
		DB: testDB(),
	}
	processor.Init()

	err := processor.New("updateresources_1224", 1002, 1003, "testimage", 2, 256)
	assert.Nil(t, err)

	err = processor.UpdateResources("updateresources_1224", "running", true, 1000, 256, 100, 200, detector.Flags{"test"})
	assert.Nil(t, err)

	app, err := processor.Get("updateresources_1224")
	assert.Nil(t, err)

	assert.Equal(t, "running", app.State)
	assert.Equal(t, true, app.OOMKilled)
	assert.Equal(t, float64(1000), app.CPUUsage)
	assert.Equal(t, 256, app.MemoryUsage)
	assert.Equal(t, 100, app.DiskUsageBytes)
	assert.Equal(t, 200, app.DiskUsageInodes)
	assert.Contains(t, app.Flags, "test")
}

func TestAppsProcessorUpdateState(t *testing.T) {
	processor := AppsProcessor{
		DB: testDB(),
	}
	processor.Init()

	err := processor.New("update_1224", 1002, 1003, "testimage", 2, 256)
	assert.Nil(t, err)

	err = processor.UpdateState("update_1224", "no-container", false)
	assert.Nil(t, err)

	app, err := processor.Get("update_1224")
	assert.Nil(t, err)

	assert.Equal(t, "no-container", app.State)
}

func TestAppsProcessorAddLabel(t *testing.T) {
	processor := AppsProcessor{
		DB: testDB(),
	}
	processor.Init()

	err := processor.New("label_1224", 1002, 1003, "testimage", 2, 256)
	assert.Nil(t, err)

	err = processor.AddLabel("label_1224", "testlabel")
	assert.Nil(t, err)

	app, err := processor.Get("label_1224")
	assert.Nil(t, err)

	assert.Equal(t, "testlabel", app.Labels[0].Value)
}

func TestAppsProcessorRemoveLabel(t *testing.T) {
	processor := AppsProcessor{
		DB: testDB(),
	}
	processor.Init()

	err := processor.New("label_1223", 1002, 1003, "testimage", 2, 256)
	assert.Nil(t, err)

	err = processor.AddLabel("label_1223", "testlabel")
	assert.Nil(t, err)

	app, err := processor.Get("label_1223")
	assert.Nil(t, err)

	assert.Equal(t, "testlabel", app.Labels[0].Value)

	err = processor.RemoveLabel("label_1223", "testlabel")
	assert.Nil(t, err)

	app, err = processor.Get("label_1223")
	assert.Nil(t, err)

	assert.Equal(t, 0, len(app.Labels))
}

func TestAppsProcessorDelete(t *testing.T) {
	processor := AppsProcessor{
		DB: testDB(),
	}
	processor.Init()

	err := processor.New("testapp_5234", 1002, 1003, "testimage", 2, 256)
	assert.Nil(t, err)

	app, err := processor.Get("testapp_5234")
	assert.Nil(t, err)
	assert.Equal(t, 256, app.Memory)

	err = processor.Delete("testapp_5234")
	assert.Nil(t, err)

	_, err = processor.Get("testapp_5234")
	assert.Error(t, err, "record not found")
}