"""Tests for export functionality."""

import os
import tempfile


from shellhist.core.export import (
    generate_alias,
    generate_alias_name,
    generate_script,
    generate_script_name,
)
from shellhist.core.patterns import CommandPattern


class TestGenerateAlias:
    """Test alias generation functionality."""

    def test_generate_alias_single_command(self) -> None:
        """Test generating alias for single command."""
        pattern = CommandPattern(
            commands=("git status",),
            frequency=5,
            percentage=10.0,
        )
        
        alias = generate_alias(pattern)
        
        assert alias.startswith("alias ")
        assert "git status" in alias

    def test_generate_alias_multiple_commands(self) -> None:
        """Test generating alias for multiple commands."""
        pattern = CommandPattern(
            commands=("git add .", "git commit", "git push"),
            frequency=3,
            percentage=5.0,
        )
        
        alias = generate_alias(pattern)
        
        assert "git add ." in alias
        assert "git commit" in alias
        assert "git push" in alias

    def test_generate_alias_custom_name(self) -> None:
        """Test generating alias with custom name."""
        pattern = CommandPattern(
            commands=("echo test",),
            frequency=1,
            percentage=1.0,
        )
        
        alias = generate_alias(pattern, alias_name="mytest")
        
        assert "mytest" in alias


class TestGenerateAliasName:
    """Test alias name generation."""

    def test_alias_name_from_command(self) -> None:
        """Test generating alias name from command."""
        pattern = CommandPattern(
            commands=("git status",),
            frequency=1,
            percentage=1.0,
        )
        
        name = generate_alias_name(pattern)
        
        assert "git" in name.lower() or "status" in name.lower()

    def test_alias_name_from_multiple_commands(self) -> None:
        """Test generating alias name from multiple commands."""
        pattern = CommandPattern(
            commands=("git add .", "git commit", "git push"),
            frequency=1,
            percentage=1.0,
        )
        
        name = generate_alias_name(pattern)
        
        assert len(name) > 0


class TestGenerateScript:
    """Test script generation functionality."""

    def test_generate_script_dry_run(self) -> None:
        """Test script generation in dry-run mode."""
        pattern = CommandPattern(
            commands=("echo hello", "echo world"),
            frequency=5,
            percentage=10.0,
        )
        
        path, content = generate_script(pattern, dry_run=True)
        
        assert "echo hello" in content
        assert "echo world" in content
        assert "shellhist_" in path

    def test_generate_script_with_custom_name(self) -> None:
        """Test script generation with custom name."""
        pattern = CommandPattern(
            commands=("ls -la",),
            frequency=1,
            percentage=1.0,
        )
        
        path, content = generate_script(
            pattern,
            script_name="my_custom_script",
            dry_run=True,
        )
        
        assert "my_custom_script" in path

    def test_generate_script_actual_write(self) -> None:
        """Test actual script file creation."""
        pattern = CommandPattern(
            commands=("echo test",),
            frequency=1,
            percentage=1.0,
        )
        
        with tempfile.TemporaryDirectory() as tmpdir:
            path, content = generate_script(
                pattern,
                output_dir=tmpdir,
                dry_run=False,
            )
            
            assert os.path.exists(path)
            
            with open(path, "r") as f:
                saved_content = f.read()
            
            assert "echo test" in saved_content

    def test_script_permissions(self) -> None:
        """Test that generated scripts are executable."""
        pattern = CommandPattern(
            commands=("echo test",),
            frequency=1,
            percentage=1.0,
        )
        
        with tempfile.TemporaryDirectory() as tmpdir:
            path, _ = generate_script(
                pattern,
                output_dir=tmpdir,
                dry_run=False,
            )
            
            mode = os.stat(path).st_mode
            assert mode & 0o111


class TestGenerateScriptName:
    """Test script name generation."""

    def test_script_name_from_commands(self) -> None:
        """Test generating script name from commands."""
        pattern = CommandPattern(
            commands=("git status", "git log"),
            frequency=1,
            percentage=1.0,
        )
        
        name = generate_script_name(pattern)
        
        assert len(name) > 0
        assert name.startswith("shellhist_")

    def test_script_name_sanitization(self) -> None:
        """Test that script names are sanitized."""
        pattern = CommandPattern(
            commands=("ls -la /tmp",),
            frequency=1,
            percentage=1.0,
        )
        
        name = generate_script_name(pattern)
        
        assert "/" not in name