import os
from unittest import mock

import pytest

from redmine_reporter.cli import main, parse_date_range

VALID_ENV = {
    "REDMINE_URL": "https://red.eltex.loc",
    "REDMINE_API_KEY": "token",
}


@pytest.fixture(autouse=True)
def _reset_config_overrides():
    """Сбрасывает CLI-переопределения Config перед каждым тестом."""
    from redmine_reporter.config import Config

    Config.set_redmine_url("")
    Config.set_redmine_api_key("")
    Config._app = None
    yield
    Config.set_redmine_url("")
    Config.set_redmine_api_key("")
    Config._app = None


@pytest.mark.parametrize(
    "date_arg, expected",
    [
        ("2026-01-01--2026-01-31", ("2026-01-01", "2026-01-31")),
        (" 2026-01-01 -- 2026-01-31 ", ("2026-01-01", "2026-01-31")),
    ],
)
def test_parse_date_range_valid(date_arg, expected):
    assert parse_date_range(date_arg) == expected


@pytest.mark.parametrize(
    "date_arg",
    [
        "20260101-20260131",
        "2026-1-01--2026-01-31",
        "2026-02-30--2026-03-01",
        "2026-02-01--2026-01-31",
    ],
)
def test_parse_date_range_invalid(date_arg):
    with pytest.raises(ValueError):
        parse_date_range(date_arg)


@mock.patch.dict(os.environ, VALID_ENV, clear=True)
@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
def test_cli_returns_zero_on_no_entries(mock_fetch):
    """None от fetch (нет time entries) -- выход 0."""
    mock_fetch.return_value = None
    code = main(["--date", "2026-01-01--2026-01-31"])
    assert code == 0


@mock.patch.dict(os.environ, {}, clear=True)
def test_cli_config_error():
    """Невалидный конфиг -- выход 1."""
    code = main(["--date", "2026-01-01--2026-01-31", "--config-path", "/nonexistent/config.yml"])
    assert code == 1


@mock.patch.dict(os.environ, VALID_ENV, clear=True)
def test_cli_invalid_date_format():
    """Неверный формат даты -- выход 1."""
    code = main(["--date", "20260101-20260131"])
    assert code == 1


class _MockIssue:
    """Простой mock Redmine Issue для CLI-тестов."""

    def __init__(self, issue_id=1, subject="Task", project="Project", status="New"):
        self.id = issue_id
        self.subject = subject
        self.project = project
        self.status = status
        self.fixed_version = None


@mock.patch.dict(os.environ, VALID_ENV, clear=True)
@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
def test_cli_unknown_output_extension(mock_fetch, tmp_path):
    """Неизвестное расширение файла -- выход 1."""
    issue = _MockIssue()
    mock_fetch.return_value = [(issue, 1.0)]
    output = str(tmp_path / "report.xyz")
    code = main(["--date", "2026-01-01--2026-01-31", "--output", output])
    assert code == 1


@mock.patch.dict(os.environ, VALID_ENV, clear=True)
@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
@mock.patch("redmine_reporter.cli.get_formatter_by_extension")
def test_cli_output_without_extension(mock_get, mock_fetch, tmp_path):
    """Файл без расширения — приложение расширяет default_format (#43)."""
    issue = _MockIssue()
    mock_fetch.return_value = [(issue, 1.0)]
    mock_formatter = mock.MagicMock()
    mock_get.return_value = mock_formatter
    output = str(tmp_path / "report")
    code = main(
        [
            "--date",
            "2026-01-01--2026-01-31",
            "--output",
            output,
            "--config-path",
            str(tmp_path / "nonexistent.yml"),
        ]
    )
    assert code == 0
    saved_path = mock_formatter.save.call_args.args[1]
    assert saved_path.endswith(".xlsx")


@mock.patch.dict(os.environ, VALID_ENV, clear=True)
@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
@mock.patch("redmine_reporter.cli.get_formatter_by_extension")
def test_cli_odt_missing_odfpy_message(mock_gf, mock_fetch, tmp_path, capsys):
    """При запросе .odt без odfpy — выход 1, понятное сообщение про odfpy."""
    issue = _MockIssue()
    mock_fetch.return_value = [(issue, 1.0)]
    mock_gf.return_value = None
    output = str(tmp_path / "report.odt")
    code = main(["--date", "2026-01-01--2026-01-31", "--output", output])
    assert code == 1
    captured = capsys.readouterr()
    assert "odfpy" in captured.err


@mock.patch.dict(os.environ, VALID_ENV, clear=True)
def test_cli_version_flag(capsys):
    """--version выводит версию и завершается с 0."""
    with pytest.raises(SystemExit) as exc_info:
        main(["--version"])
    assert exc_info.value.code == 0
    captured = capsys.readouterr()
    assert "redmine-reporter" in captured.out
    from redmine_reporter import __version__

    assert __version__ in captured.out


@mock.patch.dict(os.environ, VALID_ENV, clear=True)
@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
def test_cli_verbose_and_debug_flags_accepted(mock_fetch):
    """--verbose и --debug не ломают запуск."""
    mock_fetch.return_value = None
    code = main(["--date", "2026-01-01--2026-01-31", "--verbose"])
    assert code == 0
    code = main(["--date", "2026-01-01--2026-01-31", "--debug"])
    assert code == 0


class _MockIssue:
    """Простой mock Redmine Issue для CLI-тестов."""

    def __init__(self, issue_id=1, subject="Task", project="Project", status="New"):
        self.id = issue_id
        self.subject = subject
        self.project = project
        self.status = status
        self.fixed_version = None


@mock.patch.dict(os.environ, {}, clear=True)
@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
def test_cli_url_and_api_key_override_env(mock_fetch):
    """--url и --api-key переопределяют отсутствующие/другие env-переменные."""
    mock_fetch.return_value = None
    code = main(
        [
            "--date",
            "2026-01-01--2026-01-31",
            "--url",
            "https://other.redmine.loc",
            "--api-key",
            "cli-token",
        ]
    )
    assert code == 0


@mock.patch.dict(os.environ, {}, clear=True)
@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
def test_cli_config_file_loading(mock_fetch, tmp_path):
    """--config загружает переменные из указанного .env-файла."""
    config_path = tmp_path / "custom.env"
    config_path.write_text(
        "REDMINE_URL=https://config.redmine.loc\n" "REDMINE_API_KEY=config-token\n",
        encoding="utf-8",
    )
    mock_fetch.return_value = None
    code = main(["--date", "2026-01-01--2026-01-31", "--config", str(config_path)])
    assert code == 0


@mock.patch.dict(os.environ, VALID_ENV, clear=True)
@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
def test_cli_summary_flag_prints_totals(mock_fetch, capsys):
    """--summary выводит общее время и разбивку по проектам в stderr."""
    issue = _MockIssue()
    mock_fetch.return_value = [(issue, 1.0)]
    main(["--date", "2026-01-01--2026-01-31", "--summary"])
    captured = capsys.readouterr()
    assert "Total time" in captured.err
    assert "Project" in captured.err or "Project" in captured.out


@mock.patch.dict(os.environ, VALID_ENV, clear=True)
@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
def test_total_issues_message_goes_to_stderr(mock_fetch, capsys):
    """«Total issues» пишется в stderr, не загрязняя stdout при pipe (#28)."""
    issue = _MockIssue()
    mock_fetch.return_value = [(issue, 1.0)]
    main(["--date", "2026-01-01--2026-01-31"])
    captured = capsys.readouterr()
    assert "Total issues" not in captured.out
    assert "Total issues" in captured.err


@mock.patch.dict(os.environ, VALID_ENV, clear=True)
@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
def test_cli_prints_readable_auth_error(mock_fetch, capsys):
    """CLI выводит понятное сообщение при ошибке аутентификации."""
    from redmine_reporter.client import RedmineAPIError

    mock_fetch.side_effect = RedmineAPIError("Authentication failed: bad key")
    code = main(["--date", "2026-01-01--2026-01-31"])
    captured = capsys.readouterr()
    assert code == 1
    assert "Authentication failed" in captured.err
    assert "Redmine API error" not in captured.err


@mock.patch.dict(os.environ, VALID_ENV, clear=True)
@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
def test_cli_prints_readable_forbidden_error(mock_fetch, capsys):
    """CLI выводит понятное сообщение при недостаточных правах."""
    from redmine_reporter.client import RedmineAPIError

    mock_fetch.side_effect = RedmineAPIError("Access denied: no permission")
    code = main(["--date", "2026-01-01--2026-01-31"])
    captured = capsys.readouterr()
    assert code == 1
    assert "Access denied" in captured.err


@mock.patch.dict(os.environ, VALID_ENV, clear=True)
@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
def test_cli_prints_readable_timeout_error(mock_fetch, capsys):
    """CLI выводит понятное сообщение при таймауте."""
    from redmine_reporter.client import RedmineAPIError

    mock_fetch.side_effect = RedmineAPIError("Redmine request timed out after 30 seconds")
    code = main(["--date", "2026-01-01--2026-01-31"])
    captured = capsys.readouterr()
    assert code == 1
    assert "timed out" in captured.err


@mock.patch.dict(os.environ, VALID_ENV, clear=True)
@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
def test_cli_no_time_passed_to_formatter(mock_fetch, tmp_path):
    """CLI --no-time передаётся в файловый форматтер."""
    issue = _MockIssue()
    mock_fetch.return_value = [(issue, 1.0)]

    output = str(tmp_path / "report.xlsx")
    with mock.patch("redmine_reporter.cli.get_formatter_by_extension") as mock_get_formatter:
        mock_formatter = mock.MagicMock()
        mock_get_formatter.return_value = mock_formatter
        main(["--date", "2026-01-01--2026-01-31", "--output", output, "--no-time"])

    _, kwargs = mock_get_formatter.call_args
    assert kwargs.get("no_time") is True


@mock.patch.dict(os.environ, VALID_ENV, clear=True)
@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
def test_cli_passes_user_id_to_fetch(mock_fetch):
    """CLI --user-id передаётся в fetch_issues_with_spent_time."""
    mock_fetch.return_value = None
    main(["--date", "2026-01-01--2026-01-31", "--user-id", "42"])
    _, kwargs = mock_fetch.call_args
    assert kwargs["user_id"] == "42"


@mock.patch.dict(os.environ, VALID_ENV, clear=True)
@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
def test_cli_passes_user_login_to_fetch(mock_fetch):
    """CLI --user-login передаётся в fetch_issues_with_spent_time."""
    mock_fetch.return_value = None
    main(["--date", "2026-01-01--2026-01-31", "--user-login", "ivanov"])
    _, kwargs = mock_fetch.call_args
    assert kwargs["user_id"] == "ivanov"


@mock.patch.dict(os.environ, VALID_ENV, clear=True)
def test_cli_rejects_multiple_user_flags():
    """CLI не принимает одновременно несколько флагов пользователя."""
    code = main(
        [
            "--date",
            "2026-01-01--2026-01-31",
            "--user-id",
            "42",
            "--user-login",
            "ivanov",
        ]
    )
    assert code == 1


# ---------------------------------------------------------------------------
# --init-config tests
# ---------------------------------------------------------------------------


class TestInitConfig:
    """Tests for --init-config flag."""

    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
    def test_init_config_creates_yaml_file(self, tmp_path):
        """--init-config создаёт YAML файл с правильной структурой."""
        import yaml

        config_path = tmp_path / "config.yml"
        code = main(["--init-config", "--config-path", str(config_path)])
        assert code == 0
        assert config_path.exists()

        with open(config_path) as fh:
            data = yaml.safe_load(fh)

        assert "redmine" in data
        assert data["redmine"]["url"] == "https://red.eltex.loc"
        assert data["redmine"]["api_key"] == "${REDMINE_API_KEY}"

    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
    def test_init_config_existing_file_no_force(self, tmp_path, capsys):
        """Без --force существующий файл → предупреждение и выход 1."""
        config_path = tmp_path / "config.yml"
        config_path.write_text("existing: true")

        code = main(["--init-config", "--config-path", str(config_path)])
        assert code == 1
        captured = capsys.readouterr()
        assert "already exists" in captured.err or "already exists" in captured.out

    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
    def test_init_config_force_overwrites(self, tmp_path):
        """--init-config --force перезаписывает существующий файл."""
        import yaml

        config_path = tmp_path / "config.yml"
        config_path.write_text("existing: true")

        code = main(["--init-config", "--force", "--config-path", str(config_path)])
        assert code == 0

        with open(config_path) as fh:
            data = yaml.safe_load(fh)

        assert "redmine" in data
        assert "existing" not in data

    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
    def test_init_config_with_date_is_error(self, capsys):
        """--init-config с --date → ошибка, взаимоисключающие."""
        code = main(["--init-config", "--date", "2026-01-01--2026-01-31"])
        assert code == 1

    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
    def test_init_config_writes_secrets_as_env_ref(self, tmp_path):
        """Секреты пишутся как ${VAR} когда переменная окружения существует."""
        import yaml

        config_path = tmp_path / "config.yml"
        code = main(["--init-config", "--config-path", str(config_path)])
        assert code == 0

        with open(config_path) as fh:
            data = yaml.safe_load(fh)

        assert data["redmine"]["api_key"] == "${REDMINE_API_KEY}"

    @mock.patch.dict(os.environ, {}, clear=True)
    def test_init_config_no_env_vars(self, tmp_path):
        """Без переменных окружения --init-config создаёт скелет."""
        import yaml

        config_path = tmp_path / "config.yml"
        code = main(["--init-config", "--config-path", str(config_path)])
        assert code == 0

        with open(config_path) as fh:
            data = yaml.safe_load(fh)

        assert "redmine" in data
        assert data["redmine"]["url"] == ""
        assert data["redmine"]["api_key"] == ""


@mock.patch.dict(os.environ, {}, clear=True)
@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
def test_cli_autoloads_yaml_config(mock_fetch, tmp_path):
    """CLI автоматически подгружает YAML-конфиг при запуске."""
    config_path = tmp_path / "config.yml"
    config_path.write_text(
        "redmine:\n  url: https://yaml-redmine.example.com/\n  api_key: yaml-token\n"
    )

    mock_fetch.return_value = None
    code = main(["--date", "2026-01-01--2026-01-31", "--config-path", str(config_path)])
    assert code == 0


# ---------------------------------------------------------------------------
# #43: --output path resolution tests
# ---------------------------------------------------------------------------


class TestOutputPathResolution:
    """Tests for --output flag with path defaults."""

    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
    @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
    def test_bare_format_name_xlsx_uses_template_path(self, mock_fetch, tmp_path):
        """--output xlsx без пути → использует шаблон из конфига."""
        import yaml

        config_path = tmp_path / "config.yml"
        config_path.write_text(
            yaml.dump(
                {
                    "output": {
                        "dir": str(tmp_path / "reports"),
                        "filename": "report_{date}.{ext}",
                        "default_format": "xlsx",
                    }
                }
            )
        )

        mock_fetch.return_value = None
        code = main(
            [
                "--date",
                "2026-01-01--2026-01-31",
                "--output",
                "xlsx",
                "--config-path",
                str(config_path),
            ]
        )
        assert code == 0

    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
    @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
    def test_output_without_extension_appends_default_format(self, mock_fetch, tmp_path):
        """--output report без расширения → добавляет .xlsx."""
        issue = _MockIssue()
        mock_fetch.return_value = [(issue, 1.0)]

        output = str(tmp_path / "report")
        with mock.patch("redmine_reporter.cli.get_formatter_by_extension") as mock_get:
            mock_formatter = mock.MagicMock()
            mock_get.return_value = mock_formatter
            code = main(
                [
                    "--date",
                    "2026-01-01--2026-01-31",
                    "--output",
                    output,
                    "--config-path",
                    str(tmp_path / "nonexistent.yml"),
                ]
            )
            assert code == 0
            mock_formatter.save.assert_called_once()
            saved_path = mock_formatter.save.call_args.args[1]
            assert saved_path.endswith(".xlsx")

    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
    @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
    def test_output_with_known_extension_unchanged(self, mock_fetch, tmp_path):
        """--output report.csv с явным расширением передаётся как есть."""
        issue = _MockIssue()
        mock_fetch.return_value = [(issue, 1.0)]

        with mock.patch("redmine_reporter.cli.get_formatter_by_extension") as mock_get:
            mock_formatter = mock.MagicMock()
            mock_get.return_value = mock_formatter
            code = main(
                [
                    "--date",
                    "2026-01-01--2026-01-31",
                    "--output",
                    str(tmp_path / "report.csv"),
                    "--config-path",
                    str(tmp_path / "nonexistent.yml"),
                ]
            )
            assert code == 0
            mock_formatter.save.assert_called_once()
            saved_path = mock_formatter.save.call_args.args[1]
            assert saved_path.endswith(".csv")

    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
    @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
    def test_output_bare_format_invalid_is_treated_as_path(self, mock_fetch, tmp_path):
        """--output notanxlsx (no path, not known format) → treated as path + .xlsx appended."""
        issue = _MockIssue()
        mock_fetch.return_value = [(issue, 1.0)]

        with mock.patch("redmine_reporter.cli.get_formatter_by_extension") as mock_get:
            mock_formatter = mock.MagicMock()
            mock_get.return_value = mock_formatter
            code = main(
                [
                    "--date",
                    "2026-01-01--2026-01-31",
                    "--output",
                    "myreport",
                    "--config-path",
                    str(tmp_path / "nonexistent.yml"),
                ]
            )
            assert code == 0
            mock_formatter.save.assert_called_once()
            saved_path = mock_formatter.save.call_args.args[1]
            assert saved_path == "myreport.xlsx"


# ---------------------------------------------------------------------------
# #44: --commit tests
# ---------------------------------------------------------------------------


class TestCommitFlag:
    """Tests for --commit flag."""

    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
    @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
    @mock.patch("redmine_reporter.cli.save_period_to_config")
    def test_commit_saves_period_to_config(self, mock_save, mock_fetch, tmp_path):
        """--commit сохраняет период в YAML-конфиг."""
        import yaml

        issue = _MockIssue()
        mock_fetch.return_value = [(issue, 1.0)]

        config_path = tmp_path / "config.yml"
        config_path.write_text(yaml.dump({"period": {"precision": "date", "dynamic": True}}))

        with mock.patch("redmine_reporter.cli.get_formatter_by_extension") as mock_get:
            mock_formatter = mock.MagicMock()
            mock_get.return_value = mock_formatter
            code = main(
                [
                    "--date",
                    "2026-06-01--2026-06-30",
                    "--commit",
                    "--output",
                    str(tmp_path / "report.xlsx"),
                    "--config-path",
                    str(config_path),
                ]
            )
            assert code == 0

        mock_save.assert_called_once_with(
            str(config_path), "2026-06-01", "2026-06-30", "date", True
        )

    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
    @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
    @mock.patch("redmine_reporter.cli.save_period_to_config")
    def test_commit_with_precision_datetime_passes_datetime_strings(
        self, mock_save, mock_fetch, tmp_path
    ):
        """При precision=datetime --commit сохраняет timestamps."""
        import yaml

        issue = _MockIssue()
        mock_fetch.return_value = [(issue, 1.0)]

        config_path = tmp_path / "config.yml"
        config_path.write_text(yaml.dump({"period": {"precision": "datetime", "dynamic": True}}))

        with mock.patch("redmine_reporter.cli.get_formatter_by_extension") as mock_get:
            mock_formatter = mock.MagicMock()
            mock_get.return_value = mock_formatter
            code = main(
                [
                    "--date",
                    "2026-06-30--2026-06-30",
                    "--commit",
                    "--output",
                    str(tmp_path / "report.xlsx"),
                    "--config-path",
                    str(config_path),
                ]
            )
            assert code == 0

        call_args = mock_save.call_args
        assert call_args is not None
        saved_from, saved_to = call_args.args[1], call_args.args[2]
        assert "T" in saved_from
        assert "T" in saved_to

    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
    @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
    def test_commit_no_entries_does_not_save(self, mock_fetch, tmp_path):
        """Без записей --commit не пишет конфиг."""
        mock_fetch.return_value = None

        config_path = tmp_path / "config.yml"
        config_path.write_text("period:\n  precision: date\n  dynamic: true\n")

        code = main(
            [
                "--date",
                "2026-01-01--2026-01-31",
                "--commit",
                "--config-path",
                str(config_path),
            ]
        )
        assert code == 0

    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
    @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
    @mock.patch("redmine_reporter.cli.save_period_to_config")
    def test_commit_dynamic_false_overwrites_defaults(self, mock_save, mock_fetch, tmp_path):
        """При dynamic=false --commit перезаписывает default_from/to."""
        import yaml

        issue = _MockIssue()
        mock_fetch.return_value = [(issue, 1.0)]

        config_path = tmp_path / "config.yml"
        config_path.write_text(yaml.dump({"period": {"precision": "date", "dynamic": False}}))

        with mock.patch("redmine_reporter.cli.get_formatter_by_extension") as mock_get:
            mock_formatter = mock.MagicMock()
            mock_get.return_value = mock_formatter
            code = main(
                [
                    "--date",
                    "2026-06-01--2026-06-30",
                    "--commit",
                    "--output",
                    str(tmp_path / "report.xlsx"),
                    "--config-path",
                    str(config_path),
                ]
            )
            assert code == 0

        mock_save.assert_called_once_with(
            str(config_path), "2026-06-01", "2026-06-30", "date", False
        )

    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
    @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
    @mock.patch("redmine_reporter.cli.save_period_to_config")
    def test_commit_without_output_uses_default_path(self, mock_save, mock_fetch, tmp_path):
        """--commit без --output сохраняет файл по шаблону из конфига."""
        import yaml

        issue = _MockIssue()
        mock_fetch.return_value = [(issue, 1.0)]

        config_path = tmp_path / "config.yml"
        config_path.write_text(
            yaml.dump(
                {
                    "period": {"precision": "date", "dynamic": True},
                    "output": {
                        "dir": str(tmp_path / "reports"),
                        "filename": "report_{date}.{ext}",
                        "default_format": "xlsx",
                    },
                }
            )
        )

        with mock.patch("redmine_reporter.cli.get_formatter_by_extension") as mock_get:
            mock_formatter = mock.MagicMock()
            mock_get.return_value = mock_formatter
            code = main(
                [
                    "--date",
                    "2026-06-01--2026-06-30",
                    "--commit",
                    "--config-path",
                    str(config_path),
                ]
            )
            assert code == 0
            mock_formatter.save.assert_called_once()

    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
    @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
    @mock.patch("redmine_reporter.cli.save_period_to_config")
    def test_commit_prints_info_to_stderr(self, mock_save, mock_fetch, capsys, tmp_path):
        """--commit выводит сообщение о фиксации в stderr."""
        import yaml

        issue = _MockIssue()
        mock_fetch.return_value = [(issue, 1.0)]

        config_path = tmp_path / "config.yml"
        config_path.write_text(yaml.dump({"period": {"precision": "date", "dynamic": True}}))

        with mock.patch("redmine_reporter.cli.get_formatter_by_extension") as mock_get:
            mock_formatter = mock.MagicMock()
            mock_get.return_value = mock_formatter
            code = main(
                [
                    "--date",
                    "2026-06-01--2026-06-30",
                    "--commit",
                    "--output",
                    str(tmp_path / "report.xlsx"),
                    "--config-path",
                    str(config_path),
                ]
            )
            assert code == 0

        captured = capsys.readouterr()
        assert "commit" in captured.err.lower() or "Commit" in captured.err

    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
    @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
    @mock.patch("redmine_reporter.cli.save_period_to_config")
    def test_commit_empty_issues_no_save(self, mock_save, mock_fetch, tmp_path):
        """Пустой список задач — --commit не сохраняет конфиг."""
        import yaml

        mock_fetch.return_value = []

        config_path = tmp_path / "config.yml"
        config_path.write_text(yaml.dump({"period": {"precision": "date", "dynamic": True}}))

        code = main(
            [
                "--date",
                "2026-01-01--2026-01-31",
                "--commit",
                "--config-path",
                str(config_path),
            ]
        )
        assert code == 0
        mock_save.assert_not_called()