from __future__ import print_function

# lldb test suite imports
from lldbsuite.test.decorators import *
from lldbsuite.test.lldbtest import TestBase

# gdb-remote-specific imports
import lldbgdbserverutils
from gdbremote_testcase import GdbRemoteTestCaseBase

import binascii
import stat


class TestGdbRemotePlatformFile(GdbRemoteTestCaseBase):

    mydir = TestBase.compute_mydir(__file__)

    @skipIfWindows
    @add_test_categories(["llgs"])
    def test_platform_file_rdonly(self):
        self.vFile_test(read=True)

    @skipIfWindows
    @add_test_categories(["llgs"])
    def test_platform_file_wronly(self):
        self.vFile_test(write=True)

    @skipIfWindows
    @add_test_categories(["llgs"])
    def test_platform_file_rdwr(self):
        self.vFile_test(read=True, write=True)

    @skipIfWindows
    @add_test_categories(["llgs"])
    def test_platform_file_wronly_append(self):
        self.vFile_test(write=True, append=True)

    @skipIfWindows
    @add_test_categories(["llgs"])
    def test_platform_file_rdwr_append(self):
        self.vFile_test(read=True, write=True, append=True)

    @skipIfWindows
    @add_test_categories(["llgs"])
    def test_platform_file_wronly_trunc(self):
        self.vFile_test(write=True, trunc=True)

    @skipIfWindows
    @add_test_categories(["llgs"])
    def test_platform_file_rdwr_trunc(self):
        self.vFile_test(read=True, write=True, trunc=True)

    @skipIfWindows
    @add_test_categories(["llgs"])
    def test_platform_file_wronly_creat(self):
        self.vFile_test(write=True, creat=True)

    @skipIfWindows
    @add_test_categories(["llgs"])
    def test_platform_file_wronly_creat_excl(self):
        self.vFile_test(write=True, creat=True, excl=True)

    @skipIfWindows
    @add_test_categories(["llgs"])
    def test_platform_file_wronly_fail(self):
        server = self.connect_to_debug_monitor()
        self.assertIsNotNone(server)

        temp_path = self.getBuildArtifact("test")
        self.assertFalse(os.path.exists(temp_path))

        # attempt to open the file without O_CREAT
        self.do_handshake()
        self.test_sequence.add_log_lines(
            ["read packet: $vFile:open:%s,1,0#00" % (
                binascii.b2a_hex(temp_path.encode()).decode(),),
             {"direction": "send",
             "regex": r"^\$F-1,[0-9a-fA-F]+#[0-9a-fA-F]{2}$"}],
            True)
        self.expect_gdbremote_sequence()

    @skipIfWindows
    @add_test_categories(["llgs"])
    def test_platform_file_wronly_creat_excl_fail(self):
        server = self.connect_to_debug_monitor()
        self.assertIsNotNone(server)

        temp_file = self.getBuildArtifact("test")
        with open(temp_file, "wb"):
            pass

        # attempt to open the file with O_CREAT|O_EXCL
        self.do_handshake()
        self.test_sequence.add_log_lines(
            ["read packet: $vFile:open:%s,a01,0#00" % (
                binascii.b2a_hex(temp_file.encode()).decode(),),
             {"direction": "send",
             "regex": r"^\$F-1,[0-9a-fA-F]+#[0-9a-fA-F]{2}$"}],
            True)
        self.expect_gdbremote_sequence()

    @skipIfWindows
    @add_test_categories(["llgs"])
    def test_platform_file_size(self):
        server = self.connect_to_debug_monitor()
        self.assertIsNotNone(server)

        temp_path = self.getBuildArtifact("test")
        test_data = b"test data of some length"
        with open(temp_path, "wb") as temp_file:
            temp_file.write(test_data)

        self.do_handshake()
        self.test_sequence.add_log_lines(
            ["read packet: $vFile:size:%s#00" % (
                binascii.b2a_hex(temp_path.encode()).decode(),),
             {"direction": "send",
             "regex": r"^\$F([0-9a-fA-F]+)+#[0-9a-fA-F]{2}$",
             "capture": {1: "size"}}],
            True)
        context = self.expect_gdbremote_sequence()
        self.assertEqual(int(context["size"], 16), len(test_data))

    @skipIfWindows
    @add_test_categories(["llgs"])
    def test_platform_file_mode(self):
        server = self.connect_to_debug_monitor()
        self.assertIsNotNone(server)

        temp_path = self.getBuildArtifact("test")
        test_mode = 0o751

        with open(temp_path, "wb") as temp_file:
            os.chmod(temp_file.fileno(), test_mode)

        self.do_handshake()
        self.test_sequence.add_log_lines(
            ["read packet: $vFile:mode:%s#00" % (
                binascii.b2a_hex(temp_path.encode()).decode(),),
             {"direction": "send",
             "regex": r"^\$F([0-9a-fA-F]+)+#[0-9a-fA-F]{2}$",
             "capture": {1: "mode"}}],
            True)
        context = self.expect_gdbremote_sequence()
        self.assertEqual(int(context["mode"], 16), test_mode)

    @skipIfWindows
    @add_test_categories(["llgs"])
    def test_platform_file_exists(self):
        server = self.connect_to_debug_monitor()
        self.assertIsNotNone(server)

        temp_path = self.getBuildArtifact("test")
        with open(temp_path, "wb"):
            pass

        self.do_handshake()
        self.test_sequence.add_log_lines(
            ["read packet: $vFile:exists:%s#00" % (
                binascii.b2a_hex(temp_path.encode()).decode(),),
             "send packet: $F,1#00"],
            True)
        self.expect_gdbremote_sequence()

    @skipIfWindows
    @add_test_categories(["llgs"])
    def test_platform_file_exists_not(self):
        server = self.connect_to_debug_monitor()
        self.assertIsNotNone(server)

        test_path = self.getBuildArtifact("nonexist")
        self.do_handshake()
        self.test_sequence.add_log_lines(
            ["read packet: $vFile:exists:%s#00" % (
                binascii.b2a_hex(test_path.encode()).decode(),),
             "send packet: $F,0#00"],
            True)
        self.expect_gdbremote_sequence()

    def expect_error(self):
        self.test_sequence.add_log_lines(
            [{"direction": "send",
             "regex": r"^\$F-1,[0-9a-fA-F]+#[0-9a-fA-F]{2}$"}],
            True)
        self.expect_gdbremote_sequence()

    def vFile_test(self, read=False, write=False, append=False, trunc=False,
                   creat=False, excl=False):
        if read and write:
            mode = 2
        elif write:
            mode = 1
        else:  # read
            mode = 0
        if append:
            mode |= 8
        if creat:
            mode |= 0x200
        if trunc:
            mode |= 0x400
        if excl:
            mode |= 0x800

        old_umask = os.umask(0o22)
        try:
            server = self.connect_to_debug_monitor()
        finally:
            os.umask(old_umask)
        self.assertIsNotNone(server)

        # create a temporary file with some data
        temp_path = self.getBuildArtifact("test")
        test_data = 'some test data longer than 16 bytes\n'

        if creat:
            self.assertFalse(os.path.exists(temp_path))
        else:
            with open(temp_path, "wb") as temp_file:
                temp_file.write(test_data.encode())

        # open the file for reading
        self.do_handshake()
        self.test_sequence.add_log_lines(
            ["read packet: $vFile:open:%s,%x,1a0#00" % (
                binascii.b2a_hex(temp_path.encode()).decode(),
                mode),
             {"direction": "send",
             "regex": r"^\$F([0-9a-fA-F]+)#[0-9a-fA-F]{2}$",
             "capture": {1: "fd"}}],
            True)

        context = self.expect_gdbremote_sequence()
        self.assertIsNotNone(context)
        fd = int(context["fd"], 16)

        # read data from the file
        self.reset_test_sequence()
        self.test_sequence.add_log_lines(
            ["read packet: $vFile:pread:%x,11,10#00" % (fd,)],
            True)
        if read:
            self.test_sequence.add_log_lines(
                [{"direction": "send",
                 "regex": r"^\$F([0-9a-fA-F]+);(.*)#[0-9a-fA-F]{2}$",
                 "capture": {1: "size", 2: "data"}}],
                True)
            context = self.expect_gdbremote_sequence()
            self.assertIsNotNone(context)
            if trunc:
                self.assertEqual(context["size"], "0")
                self.assertEqual(context["data"], "")
            else:
                self.assertEqual(context["size"], "11")  # hex
                self.assertEqual(context["data"], test_data[0x10:0x10 + 0x11])
        else:
            self.expect_error()

        # another offset
        if read and not trunc:
            self.reset_test_sequence()
            self.test_sequence.add_log_lines(
                ["read packet: $vFile:pread:%x,6,3#00" % (fd,),
                 {"direction": "send",
                 "regex": r"^\$F([0-9a-fA-F]+);(.+)#[0-9a-fA-F]{2}$",
                 "capture": {1: "size", 2: "data"}}],
                True)
            context = self.expect_gdbremote_sequence()
            self.assertIsNotNone(context)
            self.assertEqual(context["size"], "6")  # hex
            self.assertEqual(context["data"], test_data[3:3 + 6])

        # write data to the file
        self.reset_test_sequence()
        self.test_sequence.add_log_lines(
            ["read packet: $vFile:pwrite:%x,6,somedata#00" % (fd,)],
            True)
        if write:
            self.test_sequence.add_log_lines(
                ["send packet: $F8#00"],
                True)
            self.expect_gdbremote_sequence()
        else:
            self.expect_error()

        # close the file
        self.reset_test_sequence()
        self.test_sequence.add_log_lines(
            ["read packet: $vFile:close:%x#00" % (fd,),
             "send packet: $F0#00"],
            True)
        self.expect_gdbremote_sequence()

        if write:
            # check if the data was actually written
            with open(temp_path, "rb") as temp_file:
                if creat:
                    self.assertEqual(os.fstat(temp_file.fileno()).st_mode & 0o7777,
                                     0o640)
                data = test_data.encode()
                if trunc or creat:
                    data = b"\0" * 6 + b"somedata"
                elif append:
                    data += b"somedata"
                else:
                    data = data[:6] + b"somedata" + data[6 + 8:]
                self.assertEqual(temp_file.read(), data)