"""
Unit and integration tests for reference counting behavior.

Tests cover:
- ref_count is set correctly for new artifacts
- ref_count increments on duplicate uploads
- ref_count query correctly identifies existing artifacts
- Artifact lookup by SHA256 hash works correctly
"""

import pytest
import io
from tests.conftest import (
    compute_sha256,
    upload_test_file,
    TEST_CONTENT_HELLO,
    TEST_HASH_HELLO,
)


class TestRefCountQuery:
    """Tests for ref_count querying and artifact lookup."""

    @pytest.mark.integration
    def test_artifact_lookup_by_sha256(self, integration_client, test_package):
        """Test artifact lookup by SHA256 hash (primary key) works correctly."""
        project, package = test_package
        content = b"unique content for lookup test"
        expected_hash = compute_sha256(content)

        # Upload a file
        upload_result = upload_test_file(
            integration_client, project, package, content, tag="v1"
        )
        assert upload_result["artifact_id"] == expected_hash

        # Look up artifact by ID (SHA256)
        response = integration_client.get(f"/api/v1/artifact/{expected_hash}")
        assert response.status_code == 200

        artifact = response.json()
        assert artifact["id"] == expected_hash
        assert artifact["sha256"] == expected_hash
        assert artifact["size"] == len(content)

    @pytest.mark.integration
    def test_ref_count_query_identifies_existing_artifact(
        self, integration_client, test_package
    ):
        """Test ref_count query correctly identifies existing artifacts by hash."""
        project, package = test_package
        content = b"content for ref count query test"
        expected_hash = compute_sha256(content)

        # Upload a file with a tag
        upload_result = upload_test_file(
            integration_client, project, package, content, tag="v1"
        )

        # Query artifact and check ref_count
        response = integration_client.get(f"/api/v1/artifact/{expected_hash}")
        assert response.status_code == 200

        artifact = response.json()
        assert artifact["ref_count"] >= 1  # At least 1 from the tag

    @pytest.mark.integration
    def test_ref_count_set_to_1_for_new_artifact_with_tag(
        self, integration_client, test_package, unique_test_id
    ):
        """Test ref_count is set to 1 for new artifacts when created with a tag."""
        project, package = test_package
        content = f"brand new content for ref count test {unique_test_id}".encode()
        expected_hash = compute_sha256(content)

        # Upload a new file with a tag
        upload_result = upload_test_file(
            integration_client, project, package, content, tag="initial"
        )

        assert upload_result["artifact_id"] == expected_hash
        assert upload_result["ref_count"] == 1
        assert upload_result["deduplicated"] is False

    @pytest.mark.integration
    def test_ref_count_increments_on_duplicate_upload_with_tag(
        self, integration_client, test_package, unique_test_id
    ):
        """Test ref_count is incremented when duplicate content is uploaded with a new tag."""
        project, package = test_package
        content = f"content that will be uploaded twice {unique_test_id}".encode()
        expected_hash = compute_sha256(content)

        # First upload with tag
        result1 = upload_test_file(
            integration_client, project, package, content, tag="v1"
        )
        assert result1["ref_count"] == 1
        assert result1["deduplicated"] is False

        # Second upload with different tag (same content)
        result2 = upload_test_file(
            integration_client, project, package, content, tag="v2"
        )
        assert result2["artifact_id"] == expected_hash
        assert result2["ref_count"] == 2
        assert result2["deduplicated"] is True

    @pytest.mark.integration
    def test_ref_count_after_multiple_tags(self, integration_client, test_package):
        """Test ref_count correctly reflects number of tags pointing to artifact."""
        project, package = test_package
        content = b"content for multiple tag test"
        expected_hash = compute_sha256(content)

        # Upload with multiple tags
        tags = ["v1", "v2", "v3", "latest"]
        for i, tag in enumerate(tags):
            result = upload_test_file(
                integration_client, project, package, content, tag=tag
            )
            assert result["artifact_id"] == expected_hash
            assert result["ref_count"] == i + 1

        # Verify final ref_count via artifact endpoint
        response = integration_client.get(f"/api/v1/artifact/{expected_hash}")
        assert response.status_code == 200
        assert response.json()["ref_count"] == len(tags)


class TestRefCountWithDeletion:
    """Tests for ref_count behavior when tags are deleted."""

    @pytest.mark.integration
    def test_ref_count_decrements_on_tag_delete(self, integration_client, test_package):
        """Test ref_count decrements when a tag is deleted."""
        project, package = test_package
        content = b"content for delete test"
        expected_hash = compute_sha256(content)

        # Upload with two tags
        upload_test_file(integration_client, project, package, content, tag="v1")
        upload_test_file(integration_client, project, package, content, tag="v2")

        # Verify ref_count is 2
        response = integration_client.get(f"/api/v1/artifact/{expected_hash}")
        assert response.json()["ref_count"] == 2

        # Delete one tag
        delete_response = integration_client.delete(
            f"/api/v1/project/{project}/{package}/tags/v1"
        )
        assert delete_response.status_code == 204

        # Verify ref_count is now 1
        response = integration_client.get(f"/api/v1/artifact/{expected_hash}")
        assert response.json()["ref_count"] == 1

    @pytest.mark.integration
    def test_ref_count_zero_after_all_tags_deleted(
        self, integration_client, test_package
    ):
        """Test ref_count goes to 0 when all tags are deleted."""
        project, package = test_package
        content = b"content that will be orphaned"
        expected_hash = compute_sha256(content)

        # Upload with one tag
        upload_test_file(integration_client, project, package, content, tag="only-tag")

        # Delete the tag
        integration_client.delete(f"/api/v1/project/{project}/{package}/tags/only-tag")

        # Verify ref_count is 0
        response = integration_client.get(f"/api/v1/artifact/{expected_hash}")
        assert response.json()["ref_count"] == 0


class TestRefCountCascadeDelete:
    """Tests for ref_count behavior during cascade deletions."""

    @pytest.mark.integration
    def test_ref_count_decrements_on_package_delete(
        self, integration_client, unique_test_id
    ):
        """Test ref_count decrements for all tags when package is deleted."""
        # Create a project and package manually (not using fixtures to control cleanup)
        project_name = f"cascade-pkg-{unique_test_id}"
        package_name = f"test-pkg-{unique_test_id}"

        # Create project
        response = integration_client.post(
            "/api/v1/projects",
            json={
                "name": project_name,
                "description": "Test project",
                "is_public": True,
            },
        )
        assert response.status_code == 200

        # Create package
        response = integration_client.post(
            f"/api/v1/project/{project_name}/packages",
            json={"name": package_name, "description": "Test package"},
        )
        assert response.status_code == 200

        # Upload content with multiple tags
        content = f"cascade delete test {unique_test_id}".encode()
        expected_hash = compute_sha256(content)

        upload_test_file(
            integration_client, project_name, package_name, content, tag="v1"
        )
        upload_test_file(
            integration_client, project_name, package_name, content, tag="v2"
        )
        upload_test_file(
            integration_client, project_name, package_name, content, tag="v3"
        )

        # Verify ref_count is 3
        response = integration_client.get(f"/api/v1/artifact/{expected_hash}")
        assert response.json()["ref_count"] == 3

        # Delete the package (should cascade delete all tags and decrement ref_count)
        delete_response = integration_client.delete(
            f"/api/v1/project/{project_name}/packages/{package_name}"
        )
        assert delete_response.status_code == 204

        # Verify ref_count is 0 (all tags were deleted)
        response = integration_client.get(f"/api/v1/artifact/{expected_hash}")
        assert response.json()["ref_count"] == 0

        # Cleanup: delete the project
        integration_client.delete(f"/api/v1/projects/{project_name}")

    @pytest.mark.integration
    def test_ref_count_decrements_on_project_delete(
        self, integration_client, unique_test_id
    ):
        """Test ref_count decrements for all tags in all packages when project is deleted."""
        # Create a project manually (not using fixtures to control cleanup)
        project_name = f"cascade-proj-{unique_test_id}"
        package1_name = f"pkg1-{unique_test_id}"
        package2_name = f"pkg2-{unique_test_id}"

        # Create project
        response = integration_client.post(
            "/api/v1/projects",
            json={
                "name": project_name,
                "description": "Test project",
                "is_public": True,
            },
        )
        assert response.status_code == 200

        # Create two packages
        for pkg_name in [package1_name, package2_name]:
            response = integration_client.post(
                f"/api/v1/project/{project_name}/packages",
                json={"name": pkg_name, "description": "Test package"},
            )
            assert response.status_code == 200

        # Upload same content with tags in both packages
        content = f"project cascade test {unique_test_id}".encode()
        expected_hash = compute_sha256(content)

        upload_test_file(
            integration_client, project_name, package1_name, content, tag="v1"
        )
        upload_test_file(
            integration_client, project_name, package1_name, content, tag="v2"
        )
        upload_test_file(
            integration_client, project_name, package2_name, content, tag="latest"
        )
        upload_test_file(
            integration_client, project_name, package2_name, content, tag="stable"
        )

        # Verify ref_count is 4 (2 tags in each of 2 packages)
        response = integration_client.get(f"/api/v1/artifact/{expected_hash}")
        assert response.json()["ref_count"] == 4

        # Delete the project (should cascade delete all packages, tags, and decrement ref_count)
        delete_response = integration_client.delete(f"/api/v1/projects/{project_name}")
        assert delete_response.status_code == 204

        # Verify ref_count is 0
        response = integration_client.get(f"/api/v1/artifact/{expected_hash}")
        assert response.json()["ref_count"] == 0

    @pytest.mark.integration
    def test_shared_artifact_ref_count_partial_decrement(
        self, integration_client, unique_test_id
    ):
        """Test ref_count correctly decrements when artifact is shared across packages."""
        # Create project with two packages
        project_name = f"shared-artifact-{unique_test_id}"
        package1_name = f"pkg1-{unique_test_id}"
        package2_name = f"pkg2-{unique_test_id}"

        # Create project
        response = integration_client.post(
            "/api/v1/projects",
            json={
                "name": project_name,
                "description": "Test project",
                "is_public": True,
            },
        )
        assert response.status_code == 200

        # Create two packages
        for pkg_name in [package1_name, package2_name]:
            response = integration_client.post(
                f"/api/v1/project/{project_name}/packages",
                json={"name": pkg_name, "description": "Test package"},
            )
            assert response.status_code == 200

        # Upload same content to both packages
        content = f"shared artifact {unique_test_id}".encode()
        expected_hash = compute_sha256(content)

        upload_test_file(
            integration_client, project_name, package1_name, content, tag="v1"
        )
        upload_test_file(
            integration_client, project_name, package2_name, content, tag="v1"
        )

        # Verify ref_count is 2
        response = integration_client.get(f"/api/v1/artifact/{expected_hash}")
        assert response.json()["ref_count"] == 2

        # Delete only package1 (package2 still references the artifact)
        delete_response = integration_client.delete(
            f"/api/v1/project/{project_name}/packages/{package1_name}"
        )
        assert delete_response.status_code == 204

        # Verify ref_count is 1 (only package2's tag remains)
        response = integration_client.get(f"/api/v1/artifact/{expected_hash}")
        assert response.json()["ref_count"] == 1

        # Cleanup
        integration_client.delete(f"/api/v1/projects/{project_name}")


class TestRefCountTagUpdate:
    """Tests for ref_count behavior when tags are updated to point to different artifacts."""

    @pytest.mark.integration
    def test_ref_count_adjusts_on_tag_update(
        self, integration_client, test_package, unique_test_id
    ):
        """Test ref_count adjusts when a tag is updated to point to a different artifact."""
        project, package = test_package

        # Upload two different artifacts
        content1 = f"artifact one {unique_test_id}".encode()
        content2 = f"artifact two {unique_test_id}".encode()
        hash1 = compute_sha256(content1)
        hash2 = compute_sha256(content2)

        # Upload first artifact with tag "latest"
        upload_test_file(integration_client, project, package, content1, tag="latest")

        # Verify first artifact has ref_count 1
        response = integration_client.get(f"/api/v1/artifact/{hash1}")
        assert response.json()["ref_count"] == 1

        # Upload second artifact with different tag
        upload_test_file(integration_client, project, package, content2, tag="stable")

        # Now update "latest" tag to point to second artifact
        # This is done by uploading the same content with the same tag
        upload_test_file(integration_client, project, package, content2, tag="latest")

        # Verify first artifact ref_count decreased to 0 (tag moved away)
        response = integration_client.get(f"/api/v1/artifact/{hash1}")
        assert response.json()["ref_count"] == 0

        # Verify second artifact ref_count increased to 2 (stable + latest)
        response = integration_client.get(f"/api/v1/artifact/{hash2}")
        assert response.json()["ref_count"] == 2

    @pytest.mark.integration
    def test_ref_count_unchanged_when_tag_same_artifact(
        self, integration_client, test_package, unique_test_id
    ):
        """Test ref_count doesn't change when tag is 'updated' to same artifact."""
        project, package = test_package

        content = f"same artifact {unique_test_id}".encode()
        expected_hash = compute_sha256(content)

        # Upload with tag
        upload_test_file(integration_client, project, package, content, tag="v1")

        # Verify ref_count is 1
        response = integration_client.get(f"/api/v1/artifact/{expected_hash}")
        assert response.json()["ref_count"] == 1

        # Upload same content with same tag (no-op)
        upload_test_file(integration_client, project, package, content, tag="v1")

        # Verify ref_count is still 1 (no double-counting)
        response = integration_client.get(f"/api/v1/artifact/{expected_hash}")
        assert response.json()["ref_count"] == 1

    @pytest.mark.integration
    def test_tag_via_post_endpoint_increments_ref_count(
        self, integration_client, test_package, unique_test_id
    ):
        """Test creating tag via POST /tags endpoint increments ref_count."""
        project, package = test_package

        content = f"tag endpoint test {unique_test_id}".encode()
        expected_hash = compute_sha256(content)

        # Upload artifact without tag
        result = upload_test_file(
            integration_client, project, package, content, filename="test.bin", tag=None
        )
        artifact_id = result["artifact_id"]

        # Verify ref_count is 0 (no tags yet)
        response = integration_client.get(f"/api/v1/artifact/{expected_hash}")
        assert response.json()["ref_count"] == 0

        # Create tag via POST endpoint
        tag_response = integration_client.post(
            f"/api/v1/project/{project}/{package}/tags",
            json={"name": "v1.0.0", "artifact_id": artifact_id},
        )
        assert tag_response.status_code == 200

        # Verify ref_count is now 1
        response = integration_client.get(f"/api/v1/artifact/{expected_hash}")
        assert response.json()["ref_count"] == 1

        # Create another tag via POST endpoint
        tag_response = integration_client.post(
            f"/api/v1/project/{project}/{package}/tags",
            json={"name": "latest", "artifact_id": artifact_id},
        )
        assert tag_response.status_code == 200

        # Verify ref_count is now 2
        response = integration_client.get(f"/api/v1/artifact/{expected_hash}")
        assert response.json()["ref_count"] == 2