from __future__ import annotations

import os

import shutil

import subprocess

import sys

import tempfile

import unittest

from pathlib import Path

from unittest import mock

sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))

from oakbench.environment import ENV_ISOLATION_VERSION, base_env  # noqa: E402

class EnvironmentPolicyTest(unittest.TestCase):

    def test_inherited_git_plumbing_cannot_redirect_any_lane(self):

        poison = {"GIT_DIR": "/wrong", "GIT_WORK_TREE": "/wrong", "GIT_INDEX_FILE": "/wrong",

                  "GIT_OBJECT_DIRECTORY": "/wrong", "GIT_CONFIG_COUNT": "1",

                  "GIT_CONFIG_KEY_0": "core.hooksPath", "GIT_CONFIG_VALUE_0": "/wrong",

                  "GIT_CONFIG_GLOBAL": "/wrong", "GIT_NO_REPLACE_OBJECTS": "0"}

        with mock.patch.dict(os.environ, poison):

            env = base_env()

        for key in poison.keys() - {"GIT_CONFIG_GLOBAL", "GIT_NO_REPLACE_OBJECTS"}:

            self.assertFalse(key in env, key)

        self.assertEqual(env["GIT_CONFIG_GLOBAL"], os.devnull)

        self.assertEqual(env["GIT_NO_REPLACE_OBJECTS"], "1")

    def test_update_check_is_disabled_despite_host_override_and_in_agent_children(self):

        from oakbench.agent_environment import agent_environment

        for hostile in ("0", "", "false"):

            with self.subTest(hostile=hostile), mock.patch.dict(os.environ, {"OAK_NO_UPDATE_CHECK": hostile}):

                env = base_env()

                self.assertEqual(env["OAK_NO_UPDATE_CHECK"], "1")

                self.assertEqual(agent_environment(env)["OAK_NO_UPDATE_CHECK"], "1")

                self.assertEqual(agent_environment({"OAK_NO_UPDATE_CHECK": hostile})["OAK_NO_UPDATE_CHECK"], "1")

        self.assertEqual(agent_environment({})["OAK_NO_UPDATE_CHECK"], "1")

        self.assertEqual(ENV_ISOLATION_VERSION, "3")

    @unittest.skipUnless(shutil.which("git"), "Git required")

    def test_real_git_initializes_requested_checkout_with_poisoned_host_environment(self):

        with tempfile.TemporaryDirectory() as tmp:

            target, poison = Path(tmp) / "target", Path(tmp) / "poison"

            target.mkdir(); poison.mkdir()

            with mock.patch.dict(os.environ, {"GIT_DIR": str(poison / ".git"), "GIT_WORK_TREE": str(poison)}):

                process = subprocess.run([shutil.which("git"), "init", "-q"], cwd=target,

                                         env=base_env(), capture_output=True, timeout=20)

            self.assertEqual(process.returncode, 0, process.stderr)

            self.assertTrue((target / ".git").is_dir())

            self.assertFalse((poison / ".git").exists())

    def test_base_env_isolates_host_home_git_config_and_locale(self) -> None:

        env = base_env()

        bench_home = Path(env["HOME"])

        self.assertNotEqual(bench_home, Path.home())

        self.assertTrue(bench_home.is_dir())

        self.assertEqual(env["XDG_CONFIG_HOME"], str(bench_home / ".config"))

        self.assertEqual(env["XDG_CACHE_HOME"], str(bench_home / ".cache"))

        self.assertEqual(env["ZDOTDIR"], str(bench_home))

        self.assertEqual(env["BASH_ENV"], os.devnull)

        self.assertEqual(env["ENV"], os.devnull)

        self.assertEqual(env["GIT_CONFIG_GLOBAL"], os.devnull)

        self.assertEqual(env["GIT_CONFIG_NOSYSTEM"], "1")

        self.assertEqual(env["LC_ALL"], "C")

        self.assertEqual(env["LANG"], "C")

        self.assertEqual(env["TZ"], "UTC")

        self.assertEqual(env["OAK_BENCH_ENV_ISOLATION_VERSION"], ENV_ISOLATION_VERSION)

    def test_base_env_accepts_explicit_stable_home(self) -> None:

        with tempfile.TemporaryDirectory() as tmp:

            home = Path(tmp) / "bench-home"

            first = base_env(home=home)

            second = base_env(home=home)

        self.assertEqual(first["HOME"], second["HOME"])

        self.assertEqual(first["XDG_CONFIG_HOME"], str(home / ".config"))

    def test_base_env_preserves_existing_path_and_explicit_tokens(self) -> None:

        old_token = os.environ.get("OAK_API_KEY")

        try:

            os.environ["OAK_API_KEY"] = "test-token"

            env = base_env()

        finally:

            if old_token is None:

                os.environ.pop("OAK_API_KEY", None)

            else:

                os.environ["OAK_API_KEY"] = old_token

        self.assertEqual(env.get("PATH"), os.environ.get("PATH"))

        self.assertEqual(env["OAK_API_KEY"], "test-token")

if __name__ == "__main__":

    unittest.main()