package users

import (
	"fmt"
	"os"
	"testing"

	"gitlab.quimbo.fr/odwrtw/canape-sql/sqltest"

	"github.com/jmoiron/sqlx"
	"github.com/lib/pq"
)

const drop = `
DROP TABLE tokens;
DROP TABLE users;

DROP FUNCTION update_modified_column();
`

var db *sqlx.DB

func init() {
	var err error

	pgdsn := os.Getenv("POSTGRES_DSN")
	db, err = sqlx.Connect("postgres", pgdsn)

	if err != nil {
		fmt.Printf("Unavailable PG tests:\n    %v\n", err)
		os.Exit(1)
	}
}

func TestUser(t *testing.T) {
	sqltest.RunWithSchema(db, usersCreate, drop, t, func(db *sqlx.DB, t *testing.T) {

		// Add a new user
		u := &User{Name: "plop"}
		err := u.Add(db)
		if err != nil {
			t.Fatal(err)
		}

		// Try add it twice
		err = u.Add(db)
		if err != nil {
			if err, ok := err.(*pq.Error); ok {
				if err.Code.Name() != "unique_violation" {
					t.Fatal(err)
				}
			}
		} else {
			t.Fatal(err)
		}

		// Get it
		u2, err := Get(db, "plop")
		if err != nil {
			t.Fatal(err)
		}
		if u2.ID != u.ID {
			t.Fatal("ID are different")
		}

		// Update it
		u2.Name = "toto"
		err = u2.Update(db)
		if err != nil {
			t.Fatal(err)
		}

		u3, err := Get(db, "toto")
		if err != nil {
			t.Fatal(err)
		}
		if u3.ID != u2.ID {
			t.Fatal("ID are different")
		}
		if u3.Name != "toto" {
			t.Fatalf("Unexpected name %q", u3.Name)
		}

		// Delete it
		err = u3.Delete(db)
		if err != nil {
			t.Fatal(err)
		}

		u, err = Get(db, "toto")
		if err == nil {
			t.Fatal("We expect an error here, the user didn't exist anymore")
		}
		if err.Error() != "sql: no rows in result set" {
			t.Fatalf("Unexpected error: %q", err)
		}
		if u != nil {
			t.Fatal("User have to be nil here")
		}
	})
}

func TestTokenAddDelete(t *testing.T) {
	sqltest.RunWithSchema(db, usersCreate, drop, t, func(db *sqlx.DB, t *testing.T) {
		// Add a new user
		u := &User{Name: "plop"}
		err := u.Add(db)
		if err != nil {
			t.Fatal(err)
		}

		// Add many token
		_, err = u.NewToken(db)
		_, err = u.NewToken(db)
		token, err := u.NewToken(db)
		if err != nil {
			t.Fatal(err)
		}

		// Get token
		tokens, err := u.GetTokens(db)
		if err != nil {
			t.Fatal(err)
		}
		if len(tokens) != 3 {
			t.Fatalf("Unexpected number of token: %q", len(tokens))
		}

		// Delete token
		err = u.DeleteToken(db, token.Value)
		if err != nil {
			t.Fatal(err)
		}
		tokens, _ = u.GetTokens(db)
		if len(tokens) != 2 {
			t.Fatalf("Unexpected number of token: %q", len(tokens))
		}

		// Delete a fake token
		err = u.DeleteToken(db, "plop")
		if err == nil {
			t.Fatalf("We expect an error when try to delete a fake token")
		}
		if err.Error() != "Unexpected number of row deleted: 0" {
			t.Fatalf("Unexpected error: %q", err)
		}

		// Remove user and test auto delete token
		u.Delete(db)
		q := `SELECT count(*) FROM tokens WHERE users_id=$1;`
		var count int
		err = db.QueryRowx(q, u.ID).Scan(&count)
		if err != nil {
			t.Fatal(err)
		}
		if count != 0 {
			t.Fatalf("Unexpected number of token: %d", count)
		}

	})
}

func TestTokenCheck(t *testing.T) {
	sqltest.RunWithSchema(db, usersCreate, drop, t, func(db *sqlx.DB, t *testing.T) {
		u := &User{Name: "plop"}
		u.Add(db)
		token, err := u.NewToken(db)

		ok, err := u.CheckToken(db, token.Value)
		if err != nil {
			t.Fatal(err)
		}
		if !ok {
			t.Fatalf("Token not found")
		}

		// test fake token
		ok, err = u.CheckToken(db, "plop")
		if err != nil {
			t.Fatal(err)
		}
		if ok {
			t.Fatalf("Token found otherwise we don't expect")
		}

	})
}

func TestAutoUpdateCols(t *testing.T) {
	sqltest.RunWithSchema(db, usersCreate, drop, t, func(db *sqlx.DB, t *testing.T) {
		u := &User{Name: "plop"}
		u.Add(db)
		u.Name = "toto"
		u.Update(db)

		if !u.Created.Before(u.Updated) {
			t.Fatalf("colum updated not auto updated on table users")
		}
	})
}