import unittest

from dumas_json_nodes import (
    DumasJSONArrayAppendNode,
    DumasJSONArrayLengthNode,
    DumasJSONArrayIteratorNode,
    DumasJSONArraySliceNode,
    DumasJSONFlattenNode,
    DumasJSONGetValueNode,
    DumasJSONHasKeyNode,
    DumasJSONKeysNode,
    DumasJSONMergeObjectsNode,
    DumasJSONPickFieldsNode,
    DumasJSONRemoveKeyNode,
    DumasJSONUnflattenNode,
    DumasJSONObjectIteratorNode,
    DumasJSONObjectToStringNode,
    DumasJSONStringToObjectNode,
    DumasJSONSetValueNode,
)

class DumasJSONNodeTests(unittest.TestCase):
    def test_parses_valid_json(self):
        node = DumasJSONStringToObjectNode()

        result = node.convert_string_to_json('{"name":"Dumas","count":2}')

        self.assertEqual(result, ({"name": "Dumas", "count": 2},))

    def test_returns_none_for_invalid_json(self):
        node = DumasJSONStringToObjectNode()

        result = node.convert_string_to_json('{"name":')

        self.assertEqual(result, (None,))

    def test_object_to_string_can_pretty_print(self):
        node = DumasJSONObjectToStringNode()

        result = node.convert_object_to_string({"b": 1, "a": 2}, True, True)

        self.assertEqual(result, ('{\n  "a": 2,\n  "b": 1\n}',))

    def test_get_value_reads_nested_paths(self):
        node = DumasJSONGetValueNode()

        result = node.get_value({"items": [{"id": "a1"}]}, "items.0.id")

        self.assertEqual(result, ("a1",))

    def test_set_value_writes_nested_paths(self):
        node = DumasJSONSetValueNode()

        result = node.set_value({"user": {"name": "Chris"}}, "user.name", '"Dumas"')

        self.assertEqual(result, ({"user": {"name": "Dumas"}},))

    def test_has_key_checks_nested_paths(self):
        node = DumasJSONHasKeyNode()

        result = node.has_key({"user": {"name": "Chris"}}, "user.name")

        self.assertEqual(result, (True,))

    def test_remove_key_removes_nested_values(self):
        node = DumasJSONRemoveKeyNode()

        result = node.remove_key({"user": {"name": "Chris", "role": "owner"}}, "user.role")

        self.assertEqual(result, ({"user": {"name": "Chris"}},))

    def test_pick_fields_builds_filtered_object(self):
        node = DumasJSONPickFieldsNode()

        result = node.pick_fields(
            {"user": {"name": "Chris", "role": "owner"}, "meta": {"active": True}},
            "user.name\nmeta.active",
        )

        self.assertEqual(result, ({"user": {"name": "Chris"}, "meta": {"active": True}},))

    def test_merge_objects_deep_merges_dictionaries(self):
        node = DumasJSONMergeObjectsNode()

        result = node.merge_objects(
            {"user": {"name": "Chris", "flags": {"admin": False}}},
            {"user": {"flags": {"admin": True}, "role": "owner"}},
        )

        self.assertEqual(
            result,
            ({"user": {"name": "Chris", "flags": {"admin": True}, "role": "owner"}},),
        )

    def test_keys_returns_key_list_and_count(self):
        node = DumasJSONKeysNode()

        result = node.list_keys({"name": "Dumas", "kind": "nodes"})

        self.assertEqual(result, (["name", "kind"], 2))

    def test_array_length_returns_length(self):
        node = DumasJSONArrayLengthNode()

        result = node.get_length([1, 2, 3, 4])

        self.assertEqual(result, (4,))

    def test_array_append_appends_parsed_value(self):
        node = DumasJSONArrayAppendNode()

        result = node.append_item([1, 2], '{"name":"Dumas"}')

        self.assertEqual(result, ([1, 2, {"name": "Dumas"}],))

    def test_array_slice_returns_subarray(self):
        node = DumasJSONArraySliceNode()

        result = node.slice_array([0, 1, 2, 3, 4], 1, 4, 2)

        self.assertEqual(result, ([1, 3],))

    def test_array_iterator_fixed_mode_uses_given_index(self):
        node = DumasJSONArrayIteratorNode()

        result = node.iterate(["a", "b", "c"], 1, "fixed")

        self.assertEqual(result, ("b", 1, 3))

    def test_array_iterator_incr_mode_advances_index(self):
        node = DumasJSONArrayIteratorNode()

        result = node.iterate(["a", "b", "c"], 1, "incr")

        self.assertEqual(result, ("c", 2, 3))

    def test_array_iterator_decr_mode_decrements_index(self):
        node = DumasJSONArrayIteratorNode()

        result = node.iterate(["a", "b", "c"], 1, "decr")

        self.assertEqual(result, ("a", 0, 3))

    def test_array_iterator_clamps_out_of_range_index(self):
        node = DumasJSONArrayIteratorNode()

        result = node.iterate(["a", "b", "c"], 99, "fixed")

        self.assertEqual(result, ("c", 2, 3))

    def test_array_iterator_handles_empty_arrays(self):
        node = DumasJSONArrayIteratorNode()

        result = node.iterate([], 0, "fixed")

        self.assertEqual(result, (None, -1, 0))

    def test_object_iterator_fixed_mode_uses_given_index(self):
        node = DumasJSONObjectIteratorNode()

        result = node.iterate({"first": "a", "second": "b", "third": "c"}, 1, "fixed")

        self.assertEqual(result, ("second", "b", 1, 3))

    def test_object_iterator_incr_mode_advances_index(self):
        node = DumasJSONObjectIteratorNode()

        result = node.iterate({"first": "a", "second": "b", "third": "c"}, 1, "incr")

        self.assertEqual(result, ("third", "c", 2, 3))

    def test_object_iterator_decr_mode_decrements_index(self):
        node = DumasJSONObjectIteratorNode()

        result = node.iterate({"first": "a", "second": "b", "third": "c"}, 1, "decr")

        self.assertEqual(result, ("first", "a", 0, 3))

    def test_object_iterator_clamps_out_of_range_index(self):
        node = DumasJSONObjectIteratorNode()

        result = node.iterate({"first": "a", "second": "b", "third": "c"}, 99, "fixed")

        self.assertEqual(result, ("third", "c", 2, 3))

    def test_object_iterator_handles_empty_objects(self):
        node = DumasJSONObjectIteratorNode()

        result = node.iterate({}, 0, "fixed")

        self.assertEqual(result, (None, None, -1, 0))

    def test_flatten_converts_nested_data_to_path_map(self):
        node = DumasJSONFlattenNode()

        result = node.flatten_json({"user": {"name": "Chris"}, "items": [{"id": 1}]})

        self.assertEqual(result, ({"user.name": "Chris", "items.0.id": 1},))

    def test_unflatten_rebuilds_nested_data(self):
        node = DumasJSONUnflattenNode()

        result = node.unflatten_json({"user.name": "Chris", "items.0.id": 1})

        self.assertEqual(result, ({"user": {"name": "Chris"}, "items": [{"id": 1}]},))


if __name__ == "__main__":
    unittest.main()