package main

import (
	"io/ioutil"
	"log"
	"math/rand"
	"os"
	"strconv"
	"testing"
	"time"

	"github.com/prologic/bitcask"
	"github.com/stretchr/testify/assert"
)

func setupTest() *Env {
	var err error
	env := &Env{}
	env.dbpath, err = ioutil.TempDir("", "shorturl")
	if err != nil {
		log.Fatal(err)
	}

	env.db, err = bitcask.Open(env.dbpath)
	if err != nil {
		log.Fatal(err)
	}

	return env
}

func (env *Env) finishTest() {
	err := env.db.Close()
	if err != nil {
		log.Fatal(err)
	}

	err = os.RemoveAll(env.dbpath)
	if err != nil {
		log.Fatal(err)
	}
}

func TestZeroURL(t *testing.T) {
	assert := assert.New(t)

	u := URL{}
	assert.Equal("", u.ID)
	assert.Equal("", u.URL)
	assert.Equal("", u.Name)
}

func TestNewURL(t *testing.T) {
	assert := assert.New(t)
	env := setupTest()

	u, err := env.NewURL("https://www.google.com")
	assert.Nil(err, nil)

	assert.NotEqual(u.ID, "")
	assert.Equal(u.URL, "https://www.google.com")
	assert.Equal(u.Name, "")

	_, err = env.NewURL("www.google.com")
	assert.NotNil(t, err)

	env.finishTest()
}

func TestSetName(t *testing.T) {
	assert := assert.New(t)
	env := setupTest()

	u := URL{}
	u.ID = "test"
	name := "testname"

	err := u.SetName(env.db, name)
	assert.Nil(err)

	val, err := env.db.Get([]byte(u.ID))
	if err != nil {
		log.Fatal(err)
	}

	assert.Equal(name, string(val))

	env.finishTest()
}

func TestURLSave(t *testing.T) {
	assert := assert.New(t)
	env := setupTest()

	u := URL{Name: "test", CreatedAt: time.Now()}
	err := u.save(env.db)
	if assert.NotNil(err) {
		assert.Contains(err.Error(), "ID")
	}

	env.finishTest()
}

func TestURLDelete(t *testing.T) {
	assert := assert.New(t)
	env := setupTest()

	// Insert a test item
	id := "test"
	err := env.db.Put([]byte(id), []byte("test"))
	if err != nil {
		t.Fatal(err)
	}

	// Test
	assert.Nil(del(env.db, id))
	assert.False(env.db.Has([]byte(id)))

	env.finishTest()
}

func TestURLGet(t *testing.T) {
	assert := assert.New(t)
	env := setupTest()

	t.Run("pass", func(t *testing.T) {
		// Insert a test item
		testUrl := URL{ID: "Test", Name: "Test", URL: "http://example.com", CreatedAt: time.Now()}
		err := testUrl.save(env.db)
		if err != nil {
			t.Fatal(err)
		}

		// Test
		u, err := get(env.db, testUrl.ID)
		if assert.Nil(err) {
			assert.Equal(testUrl.ID, u.ID)
			assert.Equal(testUrl.Name, u.Name)
			assert.Equal(testUrl.URL, u.URL)
		}
	})

	t.Run("not_exist", func(t *testing.T) {
		// Test
		_, err := get(env.db, strconv.Itoa(rand.Intn(1e6)))
		assert.NotNil(err)
	})

	env.finishTest()
}

func TestURLUpdate(t *testing.T) {
	assert := assert.New(t)
	env := setupTest()

	t.Run("pass", func(t *testing.T) {
		// Insert a test item
		testUrl := URL{ID: "Test", Name: "Test", URL: "http://example.com", CreatedAt: time.Now()}
		err := testUrl.save(env.db)
		if err != nil {
			t.Fatal(err)
		}

		// Test
		newUrlString := "http://example.com/test/"
		err = testUrl.update(env.db, newUrlString)
		if assert.Nil(err) {
			newUrl, err := get(env.db, testUrl.ID)

			assert.Nil(err)
			assert.Equal(newUrlString, newUrl.URL)
		}
	})

	t.Run("parse_error", func(t *testing.T) {
		testUrl := URL{ID: "test"}
		err := testUrl.update(env.db, "th1s#isN0tanURL$")
		assert.NotNil(err)
	})

	env.finishTest()
}