package db

import (
	"errors"
	"testing"
)

func TestCreateReleaseAndLookup(t *testing.T) {
	database := openTestDB(t)
	ownerID, _ := CreateUser(database, "josie", "hash")
	repo, _ := CreateRepo(database, ownerID, "alpha", "", "public")
	other, _ := CreateRepo(database, ownerID, "beta", "", "public")

	first, err := CreateRelease(database, repo.ID, "v1.0.0", "One", "notes **one**", ownerID)
	if err != nil {
		t.Fatalf("CreateRelease: %v", err)
	}
	if first.Tag != "v1.0.0" || first.Title != "One" || !first.AuthorID.Valid || first.AuthorID.Int64 != ownerID {
		t.Errorf("release = %+v, want tag/title/author set", first)
	}

	second, err := CreateRelease(database, repo.ID, "v1.0.1", "Two", "notes two", ownerID)
	if err != nil {
		t.Fatalf("CreateRelease second: %v", err)
	}

	if got, err := GetReleaseByID(database, first.ID); err != nil || got.Tag != "v1.0.0" {
		t.Errorf("GetReleaseByID = (%+v, %v), want v1.0.0", got, err)
	}
	if got, err := GetReleaseByTag(database, repo.ID, "v1.0.0"); err != nil || got.ID != first.ID {
		t.Errorf("GetReleaseByTag = (%+v, %v), want id %d", got, err, first.ID)
	}
	if _, err := GetReleaseByTag(database, other.ID, "v1.0.0"); !errors.Is(err, ErrNotFound) {
		t.Errorf("cross-repo GetReleaseByTag err = %v, want ErrNotFound", err)
	}

	list, err := ListReleases(database, repo.ID)
	if err != nil {
		t.Fatalf("ListReleases: %v", err)
	}
	if len(list) != 2 || list[0].ID != second.ID {
		t.Errorf("ListReleases = %+v, want newest (v1.0.1) first", list)
	}

	if _, err := CreateRelease(database, repo.ID, "v1.0.0", "dupe", "", ownerID); !errors.Is(err, ErrReleaseExists) {
		t.Errorf("duplicate CreateRelease err = %v, want ErrReleaseExists", err)
	}
}

func TestDeleteReleaseScoped(t *testing.T) {
	database := openTestDB(t)
	ownerID, _ := CreateUser(database, "josie", "hash")
	repo, _ := CreateRepo(database, ownerID, "alpha", "", "public")
	other, _ := CreateRepo(database, ownerID, "beta", "", "public")
	release, _ := CreateRelease(database, repo.ID, "v1", "One", "", ownerID)

	if err := DeleteRelease(database, other.ID, release.ID); !errors.Is(err, ErrNotFound) {
		t.Errorf("cross-repo DeleteRelease err = %v, want ErrNotFound", err)
	}
	if err := DeleteRelease(database, repo.ID, release.ID); err != nil {
		t.Fatalf("DeleteRelease: %v", err)
	}
	if _, err := GetReleaseByID(database, release.ID); !errors.Is(err, ErrNotFound) {
		t.Errorf("release after delete err = %v, want ErrNotFound", err)
	}
}

func TestReleaseAssets(t *testing.T) {
	database := openTestDB(t)
	ownerID, _ := CreateUser(database, "josie", "hash")
	repo, _ := CreateRepo(database, ownerID, "alpha", "", "public")
	other, _ := CreateRepo(database, ownerID, "beta", "", "public")
	release, _ := CreateRelease(database, repo.ID, "v1", "One", "", ownerID)

	asset, err := CreateReleaseAsset(database, release.ID, "simplegit-linux", "deadbeef", 12345)
	if err != nil {
		t.Fatalf("CreateReleaseAsset: %v", err)
	}
	if asset.Filename != "simplegit-linux" || asset.StoredName != "deadbeef" || asset.Size != 12345 {
		t.Errorf("asset = %+v", asset)
	}

	assets, err := ListReleaseAssets(database, release.ID)
	if err != nil || len(assets) != 1 {
		t.Fatalf("ListReleaseAssets = (%+v, %v), want one", assets, err)
	}
	if got, err := GetReleaseAssetForRepo(database, repo.ID, asset.ID); err != nil || got.ID != asset.ID {
		t.Errorf("GetReleaseAssetForRepo = (%+v, %v), want id %d", got, err, asset.ID)
	}
	if _, err := GetReleaseAssetForRepo(database, other.ID, asset.ID); !errors.Is(err, ErrNotFound) {
		t.Errorf("cross-repo GetReleaseAssetForRepo err = %v, want ErrNotFound", err)
	}
	if err := DeleteReleaseAsset(database, release.ID, asset.ID); err != nil {
		t.Fatalf("DeleteReleaseAsset: %v", err)
	}
	if _, err := GetReleaseAssetForRepo(database, repo.ID, asset.ID); !errors.Is(err, ErrNotFound) {
		t.Errorf("asset after delete err = %v, want ErrNotFound", err)
	}
}