import os

from clang.cindex import (
    Cursor,
    CursorKind,
    File,
    Index,
    SourceLocation,
    SourceRange,
    TranslationUnit,
    TranslationUnitLoadError,
    TranslationUnitSaveError,
)


import gc
import tempfile
import unittest
from contextlib import contextmanager
from pathlib import Path

from .util import get_cursor, get_tu

INPUTS_DIR = os.path.join(os.path.dirname(__file__), "INPUTS")


@contextmanager
def save_tu(tu):
    """Convenience API to save a TranslationUnit to a file.

    Returns the filename it was saved to.
    """
    with tempfile.NamedTemporaryFile() as t:
        tu.save(t.name)
        yield t.name


@contextmanager
def save_tu_pathlike(tu):
    """Convenience API to save a TranslationUnit to a file.

    Returns the filename it was saved to.
    """
    with tempfile.NamedTemporaryFile() as t:
        tu.save(Path(t.name))
        yield t.name


class TestTranslationUnit(unittest.TestCase):
    def test_spelling(self):
        path = os.path.join(INPUTS_DIR, "hello.cpp")
        tu = TranslationUnit.from_source(path)
        self.assertEqual(tu.spelling, path)

    def test_cursor(self):
        path = os.path.join(INPUTS_DIR, "hello.cpp")
        tu = get_tu(path)
        c = tu.cursor
        self.assertIsInstance(c, Cursor)
        self.assertIs(c.kind, CursorKind.TRANSLATION_UNIT)

    def test_parse_arguments(self):
        path = os.path.join(INPUTS_DIR, "parse_arguments.c")
        tu = TranslationUnit.from_source(path, ["-DDECL_ONE=hello", "-DDECL_TWO=hi"])
        spellings = [c.spelling for c in tu.cursor.get_children()]
        self.assertEqual(spellings[-2], "hello")
        self.assertEqual(spellings[-1], "hi")

    def test_reparse_arguments(self):
        path = os.path.join(INPUTS_DIR, "parse_arguments.c")
        tu = TranslationUnit.from_source(path, ["-DDECL_ONE=hello", "-DDECL_TWO=hi"])
        tu.reparse()
        spellings = [c.spelling for c in tu.cursor.get_children()]
        self.assertEqual(spellings[-2], "hello")
        self.assertEqual(spellings[-1], "hi")

    def test_unsaved_files(self):
        tu = TranslationUnit.from_source(
            "fake.c",
            ["-I./"],
            unsaved_files=[
                (
                    "fake.c",
                    """
#include "fake.h"
int x;
int SOME_DEFINE;
""",
                ),
                (
                    "./fake.h",
                    """
#define SOME_DEFINE y
""",
                ),
            ],
        )
        spellings = [c.spelling for c in tu.cursor.get_children()]
        self.assertEqual(spellings[-2], "x")
        self.assertEqual(spellings[-1], "y")

    def test_unsaved_files_2(self):
        from io import StringIO

        tu = TranslationUnit.from_source(
            "fake.c", unsaved_files=[("fake.c", StringIO("int x;"))]
        )
        spellings = [c.spelling for c in tu.cursor.get_children()]
        self.assertEqual(spellings[-1], "x")

    def test_from_source_accepts_pathlike(self):
        tu = TranslationUnit.from_source(
            Path("fake.c"),
            ["-Iincludes"],
            unsaved_files=[
                (
                    Path("fake.c"),
                    """
#include "fake.h"
    int x;
    int SOME_DEFINE;
    """,
                ),
                (
                    Path("includes/fake.h"),
                    """
#define SOME_DEFINE y
    """,
                ),
            ],
        )
        spellings = [c.spelling for c in tu.cursor.get_children()]
        self.assertEqual(spellings[-2], "x")
        self.assertEqual(spellings[-1], "y")

    def assert_normpaths_equal(self, path1, path2):
        """Compares two paths for equality after normalizing them with
        os.path.normpath
        """
        self.assertEqual(os.path.normpath(path1), os.path.normpath(path2))

    def test_includes(self):
        def eq(expected, actual):
            if not actual.is_input_file:
                self.assert_normpaths_equal(expected[0], actual.source.name)
                self.assert_normpaths_equal(expected[1], actual.include.name)
            else:
                self.assert_normpaths_equal(expected[1], actual.include.name)

        src = os.path.join(INPUTS_DIR, "include.cpp")
        h1 = os.path.join(INPUTS_DIR, "header1.h")
        h2 = os.path.join(INPUTS_DIR, "header2.h")
        h3 = os.path.join(INPUTS_DIR, "header3.h")
        inc = [(src, h1), (h1, h3), (src, h2), (h2, h3)]

        tu = TranslationUnit.from_source(src)
        for i in zip(inc, tu.get_includes()):
            eq(i[0], i[1])

    def test_inclusion_directive(self):
        src = os.path.join(INPUTS_DIR, "include.cpp")
        h1 = os.path.join(INPUTS_DIR, "header1.h")
        h2 = os.path.join(INPUTS_DIR, "header2.h")
        h3 = os.path.join(INPUTS_DIR, "header3.h")
        inc = [h1, h3, h2, h3, h1]

        tu = TranslationUnit.from_source(
            src, options=TranslationUnit.PARSE_DETAILED_PROCESSING_RECORD
        )
        inclusion_directive_files = [
            c.get_included_file().name
            for c in tu.cursor.get_children()
            if c.kind == CursorKind.INCLUSION_DIRECTIVE
        ]
        for i in zip(inc, inclusion_directive_files):
            self.assert_normpaths_equal(i[0], i[1])

    def test_save(self):
        """Ensure TranslationUnit.save() works."""

        tu = get_tu("int foo();")

        with save_tu(tu) as path:
            self.assertTrue(os.path.exists(path))
            self.assertGreater(os.path.getsize(path), 0)

    def test_save_pathlike(self):
        """Ensure TranslationUnit.save() works with PathLike filename."""

        tu = get_tu("int foo();")

        with save_tu_pathlike(tu) as path:
            self.assertTrue(os.path.exists(path))
            self.assertGreater(os.path.getsize(path), 0)

    def test_save_translation_errors(self):
        """Ensure that saving to an invalid directory raises."""

        tu = get_tu("int foo();")

        path = "/does/not/exist/llvm-test.ast"
        self.assertFalse(os.path.exists(os.path.dirname(path)))

        with self.assertRaises(TranslationUnitSaveError) as cm:
            tu.save(path)
        ex = cm.exception
        expected = TranslationUnitSaveError.ERROR_UNKNOWN
        self.assertEqual(ex.save_error, expected)

    def test_load(self):
        """Ensure TranslationUnits can be constructed from saved files."""

        tu = get_tu("int foo();")
        self.assertEqual(len(tu.diagnostics), 0)
        with save_tu(tu) as path:
            self.assertTrue(os.path.exists(path))
            self.assertGreater(os.path.getsize(path), 0)

            tu2 = TranslationUnit.from_ast_file(filename=path)
            self.assertEqual(len(tu2.diagnostics), 0)

            foo = get_cursor(tu2, "foo")
            self.assertIsNotNone(foo)

            # Just in case there is an open file descriptor somewhere.
            del tu2

    def test_load_pathlike(self):
        """Ensure TranslationUnits can be constructed from saved files -
        PathLike variant."""
        tu = get_tu("int foo();")
        self.assertEqual(len(tu.diagnostics), 0)
        with save_tu(tu) as path:
            tu2 = TranslationUnit.from_ast_file(filename=Path(path))
            self.assertEqual(len(tu2.diagnostics), 0)

            foo = get_cursor(tu2, "foo")
            self.assertIsNotNone(foo)

            # Just in case there is an open file descriptor somewhere.
            del tu2

    def test_index_parse(self):
        path = os.path.join(INPUTS_DIR, "hello.cpp")
        index = Index.create()
        tu = index.parse(path)
        self.assertIsInstance(tu, TranslationUnit)

    def test_get_file(self):
        """Ensure tu.get_file() works appropriately."""

        tu = get_tu("int foo();")

        f = tu.get_file("t.c")
        self.assertIsInstance(f, File)
        self.assertEqual(f.name, "t.c")

        with self.assertRaises(Exception):
            f = tu.get_file("foobar.cpp")

    def test_get_file_pathlike(self):
        """Ensure tu.get_file() works appropriately with PathLike filenames."""

        tu = get_tu("int foo();")

        f = tu.get_file(Path("t.c"))
        self.assertIsInstance(f, File)
        self.assertEqual(f.name, "t.c")

        with self.assertRaises(Exception):
            f = tu.get_file(Path("foobar.cpp"))

    def test_get_source_location(self):
        """Ensure tu.get_source_location() works."""

        tu = get_tu("int foo();")

        location = tu.get_location("t.c", 2)
        self.assertIsInstance(location, SourceLocation)
        self.assertEqual(location.offset, 2)
        self.assertEqual(location.file.name, "t.c")

        location = tu.get_location("t.c", (1, 3))
        self.assertIsInstance(location, SourceLocation)
        self.assertEqual(location.line, 1)
        self.assertEqual(location.column, 3)
        self.assertEqual(location.file.name, "t.c")

    def test_get_source_range(self):
        """Ensure tu.get_source_range() works."""

        tu = get_tu("int foo();")

        r = tu.get_extent("t.c", (1, 4))
        self.assertIsInstance(r, SourceRange)
        self.assertEqual(r.start.offset, 1)
        self.assertEqual(r.end.offset, 4)
        self.assertEqual(r.start.file.name, "t.c")
        self.assertEqual(r.end.file.name, "t.c")

        r = tu.get_extent("t.c", ((1, 2), (1, 3)))
        self.assertIsInstance(r, SourceRange)
        self.assertEqual(r.start.line, 1)
        self.assertEqual(r.start.column, 2)
        self.assertEqual(r.end.line, 1)
        self.assertEqual(r.end.column, 3)
        self.assertEqual(r.start.file.name, "t.c")
        self.assertEqual(r.end.file.name, "t.c")

        start = tu.get_location("t.c", 0)
        end = tu.get_location("t.c", 5)

        r = tu.get_extent("t.c", (start, end))
        self.assertIsInstance(r, SourceRange)
        self.assertEqual(r.start.offset, 0)
        self.assertEqual(r.end.offset, 5)
        self.assertEqual(r.start.file.name, "t.c")
        self.assertEqual(r.end.file.name, "t.c")

    def test_get_tokens_gc(self):
        """Ensures get_tokens() works properly with garbage collection."""

        tu = get_tu("int foo();")
        r = tu.get_extent("t.c", (0, 10))
        tokens = list(tu.get_tokens(extent=r))

        self.assertEqual(tokens[0].spelling, "int")
        gc.collect()
        self.assertEqual(tokens[0].spelling, "int")

        del tokens[1]
        gc.collect()
        self.assertEqual(tokens[0].spelling, "int")

        # May trigger segfault if we don't do our job properly.
        del tokens
        gc.collect()
        gc.collect()  # Just in case.

    def test_fail_from_source(self):
        path = os.path.join(INPUTS_DIR, "non-existent.cpp")
        try:
            tu = TranslationUnit.from_source(path)
        except TranslationUnitLoadError:
            tu = None
        self.assertEqual(tu, None)

    def test_fail_from_ast_file(self):
        path = os.path.join(INPUTS_DIR, "non-existent.ast")
        try:
            tu = TranslationUnit.from_ast_file(path)
        except TranslationUnitLoadError:
            tu = None
        self.assertEqual(tu, None)
