package rbac

import (
	"database/sql"
	_ "github.com/mattn/go-sqlite3"
	"reflect"
	"testing"
)

func compareSlices(a, b []Role) bool {
	if len(a) != len(b) {
		return false
	}
	for i, v := range a {
		if v != b[i] {
			return false
		}
	}
	return true
}

func TestSqlRbacStore(t *testing.T) {
	db, err := sql.Open("sqlite3", ":memory:")
	if err != nil {
		t.Fatal(err)
	}
	defer db.Close()

	store, err := NewSqlRbacStore(db)
	if err != nil {
		t.Fatal(err)
	}

	// Create test data
	_, err = db.Exec(`
        INSERT INTO roles (id, name) VALUES (1, 'admin');
        INSERT INTO user_roles (user_id, role_id) VALUES (1, 1);
        INSERT INTO capabilities (id, name, description) VALUES (1, 'Send Email', '');
        INSERT INTO role_capabilities (role_id, capability_id) VALUES (1, 1);
    `)
	if err != nil {
		t.Fatal(err)
	}

	tests := []struct {
		name       string
		userID     int
		capability string
		wantHas    bool
	}{
		{
			name:       "User has capability",
			userID:     1,
			capability: "Send Email",
			wantHas:    true,
		},
		{
			name:       "User does not have capability",
			userID:     2,
			capability: "Send Email",
			wantHas:    false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			has, err := store.HasCapability(tt.userID, tt.capability)
			if err != nil {
				t.Fatal(err)
			}
			if has != tt.wantHas {
				t.Errorf("want %v, got %v", tt.wantHas, has)
			}

			roles, err := store.GetUserRoles(tt.userID)
			if err != nil {
				t.Fatal(err)
			}
			wantRoles := []Role{}
			if tt.userID == 1 {
				wantRoles = append(wantRoles, Role{ID: 1, Name: "admin"})
			}
			if !compareSlices(roles, wantRoles) {
				t.Errorf("want %v, got %v", wantRoles, roles)
			}

			capabilities, err := store.GetRoleCapabilities(1)
			if err != nil {
				t.Fatal(err)
			}
			wantCapabilities := []Capability{{ID: 1, Name: "Send Email"}}
			if !reflect.DeepEqual(capabilities, wantCapabilities) {
				t.Errorf("want %v, got %v", wantCapabilities, capabilities)
			}
		})
	}

}