package abfapi

import (
    "io/ioutil"
    "log"
    "net/http"
    "net/http/httptest"
    "os"
    "testing"

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

// Создаем мок-сервер для тестирования
func setupMockServer(t *testing.T) (*httptest.Server, *AbfJson) {
    server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        switch r.URL.Path {
        case "/api/v1/arches.json":
            w.WriteHeader(http.StatusOK)
            w.Write([]byte(`{"architectures": ["x86_64", "arm64"]}`))
        case "/api/v1/platforms.json":
            w.WriteHeader(http.StatusOK)
            w.Write([]byte(`{"platforms": [{"id": 1, "name": "Ubuntu"}, {"id": 2, "name": "CentOS"}]}`))
        case "/api/v1/platforms/1.json":
            w.WriteHeader(http.StatusOK)
            w.Write([]byte(`{"platform": {"id": 1, "name": "Ubuntu"}}`))
        case "/api/v1/users/testuser.json":
            w.WriteHeader(http.StatusOK)
            w.Write([]byte(`{"user": {"id": 1, "username": "testuser"}}`))
        case "/api/v1/build_lists.json":
            if r.Method == http.MethodGet {
                w.WriteHeader(http.StatusOK)
                w.Write([]byte(`{"build_lists": [{"id": 1, "name": "BuildList1"}]}`))
            } else if r.Method == http.MethodPost {
                w.WriteHeader(http.StatusOK)
                w.Write([]byte(`{"build_list": {"id": 2, "name": "NewBuildList"}}`))
            } else {
                w.WriteHeader(http.StatusMethodNotAllowed)
            }
        case "/api/v1/build_lists/1.json":
            w.WriteHeader(http.StatusOK)
            w.Write([]byte(`{"build_list": {"id": 1, "name": "BuildList1"}}`))
        case "/api/v1/build_lists/1/publish.json":
            w.WriteHeader(http.StatusOK)
            w.Write([]byte(`{"status": "published"}`))
        case "/api/v1/projects/1.json":
            w.WriteHeader(http.StatusOK)
            w.Write([]byte(`{"project": {"id": 1, "name": "TestProject"}}`))
        case "/api/v1/projects/get_id.json":
            w.WriteHeader(http.StatusOK)
            w.Write([]byte(`{"project": {"id": 1, "name": "TestProject"}}`))
        case "/api/v1/projects.json":
            w.WriteHeader(http.StatusOK)
            w.Write([]byte(`{"projects": [{"id": 1, "name": "TestProject"}]}`))
        case "/api/v1/file_stores.json":
            w.WriteHeader(http.StatusOK)
            w.Write([]byte(`[{"sha1_hash": "1234567890abcdef1234567890abcdef12345678", "file_name": "testfile.txt"}]`))
        case "/api/v1/upload":
            if r.Method == http.MethodPost {
                w.WriteHeader(http.StatusOK)
                w.Write([]byte(`{"sha1_hash": "1234567890abcdef1234567890abcdef12345678"}`))
            } else {
                w.WriteHeader(http.StatusMethodNotAllowed)
            }
        case "/api/v1/file_stores/1234567890abcdef1234567890abcdef12345678":
            w.WriteHeader(http.StatusOK)
            w.Write([]byte("Hello, world!"))
        default:
            w.WriteHeader(http.StatusNotFound)
        }
    }))

    logger := log.New(ioutil.Discard, "", log.LstdFlags)
    client, err := NewAbfJson(server.URL, server.URL, "testuser", "testpass", logger)
    assert.NoError(t, err)

    return server, client
}

func TestNewAbfJson(t *testing.T) {
    logger := log.New(ioutil.Discard, "", log.LstdFlags)
    client, err := NewAbfJson("http://example.com", "http://filestore.example.com", "testuser", "testpass", logger)
    assert.NoError(t, err)
    assert.NotNil(t, client)
    assert.Equal(t, "http://example.com", client.abfURL)
    assert.Equal(t, "http://filestore.example.com", client.fileStoreURL)
    assert.Equal(t, "dGVzdHVzZXI6dGVzdHBhc3M=", client.base64AuthStr)
}

func TestGetArchitectures(t *testing.T) {
    server, client := setupMockServer(t)
    defer server.Close()

    arches, err := client.GetArchitectures()
    assert.NoError(t, err)
    assert.NotNil(t, arches)
    assert.Contains(t, arches, "architectures")
    assert.IsType(t, []interface{}{}, arches["architectures"])
}

func TestGetPlatforms(t *testing.T) {
    server, client := setupMockServer(t)
    defer server.Close()

    platforms, err := client.GetPlatforms("")
    assert.NoError(t, err)
    assert.NotNil(t, platforms)
    assert.Contains(t, platforms, "platforms")
    assert.IsType(t, []interface{}{}, platforms["platforms"])
}

func TestGetPlatformByID(t *testing.T) {
    server, client := setupMockServer(t)
    defer server.Close()

    platform, err := client.GetPlatformByID(1)
    assert.NoError(t, err)
    assert.NotNil(t, platform)
    assert.Contains(t, platform, "platform")
    assert.IsType(t, map[string]interface{}{}, platform["platform"])
}

func TestGetUserID(t *testing.T) {
    server, client := setupMockServer(t)
    defer server.Close()

    user, err := client.GetUserID("testuser")
    assert.NoError(t, err)
    assert.NotNil(t, user)
    assert.Contains(t, user, "user")
    assert.IsType(t, map[string]interface{}{}, user["user"])
}

func TestGetBuildListByID(t *testing.T) {
    server, client := setupMockServer(t)
    defer server.Close()

    buildList, err := client.GetBuildListByID(1)
    assert.NoError(t, err)
    assert.NotNil(t, buildList)
    assert.Contains(t, buildList, "build_list")
    assert.IsType(t, map[string]interface{}{}, buildList["build_list"])
}

func TestPublish(t *testing.T) {
    server, client := setupMockServer(t)
    defer server.Close()

    result, err := client.Publish(1)
    assert.NoError(t, err)
    assert.NotNil(t, result)
    assert.Contains(t, result, "status")
    assert.Equal(t, "published", result["status"])
}

func TestGetProjectByID(t *testing.T) {
    server, client := setupMockServer(t)
    defer server.Close()

    project, err := client.GetProjectByID(1)
    assert.NoError(t, err)
    assert.NotNil(t, project)
    assert.Contains(t, project, "project")
    assert.IsType(t, map[string]interface{}{}, project["project"])
}

func TestGetProjectIDByName(t *testing.T) {
    server, client := setupMockServer(t)
    defer server.Close()

    project, err := client.GetProjectIDByName([2]string{"owner", "TestProject"})
    assert.NoError(t, err)
    assert.NotNil(t, project)
    assert.Contains(t, project, "project")
    assert.IsType(t, map[string]interface{}{}, project["project"])
}

func TestNewProject(t *testing.T) {
    server, client := setupMockServer(t)
    defer server.Close()

    data := map[string]interface{}{
        "name":        "NewProject",
        "description": "This is a new project",
    }

    project, err := client.NewProject(data)
    assert.NoError(t, err)
    assert.NotNil(t, project)
    assert.Contains(t, project, "projects")
    assert.IsType(t, []interface{}{}, project["projects"])
}

func TestUploadFile(t *testing.T) {
    server, client := setupMockServer(t)
    defer server.Close()

    // Создаем временный файл для загрузки
    tmpfile, err := ioutil.TempFile("", "testfile")
    if err != nil {
        t.Fatal(err)
    }
    defer os.Remove(tmpfile.Name())

    // Записываем данные в файл
    _, err = tmpfile.Write([]byte("Hello, world!"))
    if err != nil {
        t.Fatal(err)
    }
    if err := tmpfile.Close(); err != nil {
        t.Fatal(err)
    }

    hash, err := client.UploadFile(tmpfile.Name(), true)
    assert.NoError(t, err)
    assert.Equal(t, "1234567890abcdef1234567890abcdef12345678", hash)
}

func TestGetFileInfoByHash(t *testing.T) {
    server, client := setupMockServer(t)
    defer server.Close()

    info, err := client.GetFileInfoByHash("1234567890abcdef1234567890abcdef12345678")
    assert.NoError(t, err)
    assert.NotNil(t, info)
    assert.Len(t, info, 1)
    assert.Contains(t, info[0], "sha1_hash")
    assert.Equal(t, "1234567890abcdef1234567890abcdef12345678", info[0]["sha1_hash"])
}

func TestFetchFile(t *testing.T) {
    server, client := setupMockServer(t)
    defer server.Close()

    // Создаем временный файл для сохранения загруженных данных
    tmpfile, err := ioutil.TempFile("", "downloadedfile")
    if err != nil {
        t.Fatal(err)
    }
    defer os.Remove(tmpfile.Name())
    defer tmpfile.Close()

    err = client.FetchFile("1234567890abcdef1234567890abcdef12345678", tmpfile.Name())
    assert.NoError(t, err)

    // Проверяем содержимое файла
    content, err := ioutil.ReadFile(tmpfile.Name())
    if err != nil {
        t.Fatal(err)
    }
    assert.Equal(t, "Hello, world!", string(content))
}