/*

  This file is part of Dconf Editor

  Dconf Editor is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  Dconf Editor is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License

  along with Dconf Editor.  If not, see <https://www.gnu.org/licenses/>.

*/

using Gtk;

public interface KeyEditorChild : Widget

{

    public signal void value_has_changed (bool is_valid = true);

    public abstract Variant get_variant ();

    public signal void child_activated ();

    public abstract void reload (Variant gvariant);

}

private class KeyEditorChildSingle : Label, KeyEditorChild

{

    private Variant variant;

    public KeyEditorChildSingle (Variant key_value, string text)

    {

        variant = key_value;

        set_label (text);

        show ();

    }

    public Variant get_variant ()

    {

        return variant;

    }

    public void reload (Variant gvariant) {}

}

private class KeyEditorChildEnum : MenuButton, KeyEditorChild

{

    private Variant variant;

    private GLib.Action action;

    public KeyEditorChildEnum (Variant initial_value, bool delay_mode, bool has_planned_change, Variant range_content)

    {

        this.visible = true;

        this.hexpand = true;

        this.halign = Align.START;

        this.use_popover = true;

        this.width_request = 100;

        ContextPopover popover = new ContextPopover ();

        action = popover.create_buttons_list (false, delay_mode, has_planned_change, "<enum>", initial_value, range_content);

        popover.set_relative_to (this);

        popover.value_changed.connect ((gvariant) => {

                if (gvariant == null)   // TODO better (1/3)

                    assert_not_reached ();

                reload ((!) gvariant);

                popover.closed ();

                value_has_changed ();

            });

        reload (initial_value);

        this.set_popover ((Popover) popover);

    }

    public Variant get_variant ()

    {

        return variant;

    }

    public void reload (Variant gvariant)

    {

        variant = gvariant;

        VariantType type = gvariant.get_type ();

        label = type == VariantType.STRING ? gvariant.get_string () : gvariant.print (false);

        action.change_state (new Variant.maybe (null, new Variant.maybe (type, gvariant)));

    }

}

private class KeyEditorChildFlags : Grid, KeyEditorChild

{

    private string [] all_flags;

    private ContextPopover popover = new ContextPopover ();

    private Variant variant;

    private Label label = new Label ("");

    public KeyEditorChildFlags (Variant initial_value, string [] _all_flags, string [] active_flags)

    {

        all_flags = _all_flags;

        this.visible = true;

        this.hexpand = true;

        this.orientation = Orientation.HORIZONTAL;

        this.column_spacing = 8;

        MenuButton button = new MenuButton ();

        button.visible = true;

        button.use_popover = true;

        button.halign = Align.START;

        button.get_style_context ().add_class ("image-button");

        this.add (button);

        label.visible = true;

        label.halign = Align.START;

        label.hexpand = true;

        this.add (label);

        popover.create_flags_list (active_flags, all_flags);

        popover.set_relative_to (button);

        popover.value_changed.connect ((gvariant) => {

                if (gvariant == null)   // TODO better (2/3)

                    assert_not_reached ();

                reload ((!) gvariant);

                value_has_changed ();

            });

        reload (initial_value);

        button.set_popover ((Popover) popover);

    }

    public void update_flags (string [] active_flags)

    {

        foreach (string flag in all_flags)

            popover.update_flag_status (flag, flag in active_flags);

    }

    public Variant get_variant ()

    {

        return variant;

    }

    public void reload (Variant gvariant)

    {

        this.variant = gvariant;

        label.label = gvariant.print (false);

    }

}

private class KeyEditorChildNullableBool : MenuButton, KeyEditorChild

{

    private Variant variant;

    private Variant? maybe_variant;

    private GLib.Action action;

    public KeyEditorChildNullableBool (Variant initial_value, bool delay_mode, bool has_planned_change, Variant? range_content_or_null)

    {

        this.visible = true;

        this.hexpand = true;

        this.halign = Align.START;

        this.use_popover = true;

        this.width_request = 100;

        ContextPopover popover = new ContextPopover ();

        action = popover.create_buttons_list (false, delay_mode, has_planned_change, "mb", initial_value, range_content_or_null);

        popover.set_relative_to (this);

        popover.value_changed.connect ((gvariant) => {

                if (gvariant == null)   // TODO better (3/3)

                    assert_not_reached ();

                reload ((!) gvariant);

                popover.closed ();

                value_has_changed ();

            });

        reload (initial_value);

        this.set_popover ((Popover) popover);

    }

    public Variant get_variant ()

    {

        return variant;

    }

    public void reload (Variant gvariant)

    {

        variant = gvariant;

        maybe_variant = variant.get_maybe ();

        if (maybe_variant == null)

            label = Key.cool_boolean_text_value (null);

        else

            label = Key.cool_boolean_text_value (((!) maybe_variant).get_boolean ());

        action.change_state (new Variant.maybe (null, new Variant.maybe (new VariantType ("mb"), gvariant)));

    }

}

private class KeyEditorChildBool : Box, KeyEditorChild // might be managed by action, but can't find a way to ensure one-and-only-one button is active  // https://bugzilla.gnome.org/show_bug.cgi?id=769876

{

    private ToggleButton button_true;

    public KeyEditorChildBool (bool initial_value)

    {

        this.visible = true;

        this.hexpand = true;

        this.orientation = Orientation.HORIZONTAL;

        this.halign = Align.START;

        this.homogeneous = true;

        this.width_request = 100;

        this.get_style_context ().add_class ("linked");

        ToggleButton button_false = new ToggleButton ();

        button_false.visible = true;

        button_false.label = Key.cool_boolean_text_value (false);

        this.add (button_false);

        button_true = new ToggleButton ();

        button_true.visible = true;

        button_true.label = Key.cool_boolean_text_value (true);

        this.add (button_true);

        button_true.active = initial_value;

        button_true.bind_property ("active", button_false, "active", BindingFlags.INVERT_BOOLEAN|BindingFlags.SYNC_CREATE|BindingFlags.BIDIRECTIONAL);

        button_true.toggled.connect (() => value_has_changed ());

    }

    public Variant get_variant ()

    {

        return new Variant.boolean (button_true.active);

    }

    public void reload (Variant gvariant)

    {

        button_true.active = gvariant.get_boolean ();

    }

}

private class KeyEditorChildNumberDouble : Entry, KeyEditorChild

{

    private Variant variant;

    private ulong deleted_text_handler = 0;

    private ulong inserted_text_handler = 0;

    construct

    {

        get_style_context ().add_class ("key-editor-child-entry");

    }

    public KeyEditorChildNumberDouble (Variant initial_value)

    {

        this.variant = initial_value;

        this.visible = true;

        this.hexpand = true;

        this.secondary_icon_activatable = false;

        this.set_icon_tooltip_text (EntryIconPosition.SECONDARY, _("Failed to parse as double."));

        this.text = initial_value.print (false);

        EntryBuffer ref_buffer = buffer;    // an EntryBuffer doesn't emit a "destroy" signal

        deleted_text_handler = ref_buffer.deleted_text.connect (() => value_has_changed (test_value ()));

        inserted_text_handler = ref_buffer.inserted_text.connect (() => value_has_changed (test_value ()));

        ulong entry_activate_handler = activate.connect (() => { if (test_value ()) child_activated (); });

        destroy.connect (() => {

                ref_buffer.disconnect (deleted_text_handler);

                ref_buffer.disconnect (inserted_text_handler);

                disconnect (entry_activate_handler);

            });

    }

    private bool test_value ()

    {

        string tmp_text = this.text; // don't put in the try{} for correct C code

        try

        {

            Variant? tmp_variant = Variant.parse (VariantType.DOUBLE, tmp_text);

            variant = (!) tmp_variant;

            StyleContext context = get_style_context ();

            if (context.has_class ("error"))

                context.remove_class ("error");

            set_icon_from_icon_name (EntryIconPosition.SECONDARY, null);

            return true;

        }

        catch (VariantParseError e)

        {

            StyleContext context = get_style_context ();

            if (!context.has_class ("error"))

                context.add_class ("error");

            secondary_icon_name = "dialog-error-symbolic";

            return false;

        }

    }

    public Variant get_variant ()

    {

        return variant;

    }

    private void set_lock (bool state)

        requires (deleted_text_handler != 0 && inserted_text_handler != 0)

    {

        if (state)

        {

            SignalHandler.block (buffer, deleted_text_handler);

            SignalHandler.block (buffer, inserted_text_handler);

        }

        else

        {

            SignalHandler.unblock (buffer, deleted_text_handler);

            SignalHandler.unblock (buffer, inserted_text_handler);

        }

    }

    public void reload (Variant gvariant)

    {

        set_lock (true);

        this.text = gvariant.print (false);

        if (!test_value ())

            assert_not_reached ();

        set_lock (false);

    }

}

private class KeyEditorChildNumberInt : SpinButton, KeyEditorChild

{

    private string key_type;

    private ulong deleted_text_handler = 0;

    private ulong inserted_text_handler = 0;

    public KeyEditorChildNumberInt (Variant initial_value, string type_string, Variant? range_content_or_null)

        requires (type_string == "y" || type_string == "n" || type_string == "q" || type_string == "i" || type_string == "u" || type_string == "h")     // TODO type_string == "x" || type_string == "t" ||

    {

        this.key_type = type_string;

        this.visible = true;

        this.hexpand = true;

        this.halign = Align.START;

        double min, max;

        if (range_content_or_null != null)

        {

            min = get_variant_as_double (((!) range_content_or_null).get_child_value (0));

            max = get_variant_as_double (((!) range_content_or_null).get_child_value (1));

        }

        else

            get_min_and_max_double (out min, out max, type_string);

        Adjustment adjustment = new Adjustment (get_variant_as_double (initial_value), min, max, 1.0, 5.0, 0.0);

        this.configure (adjustment, 1.0, 0);

        this.update_policy = SpinButtonUpdatePolicy.IF_VALID;

        this.snap_to_ticks = true;

        this.numeric = true;

        this.input_purpose = InputPurpose.NUMBER;   // TODO could be DIGITS for UnsignedInt

        this.width_chars = 30;

        EntryBuffer ref_buffer = buffer;    // an EntryBuffer doesn't emit a "destroy" signal

        deleted_text_handler = ref_buffer.deleted_text.connect (() => value_has_changed ());

        inserted_text_handler = ref_buffer.inserted_text.connect (() => value_has_changed ());

        ulong entry_activate_handler = activate.connect (() => { update (); child_activated (); });

        destroy.connect (() => {

                ref_buffer.disconnect (deleted_text_handler);

                ref_buffer.disconnect (inserted_text_handler);

                disconnect (entry_activate_handler);

            });

    }

    private static void get_min_and_max_double (out double min, out double max, string variant_type)

    {

        switch (variant_type)

        {

            case "y": min = (double) uint8.MIN;     max = (double) uint8.MAX;   break;

            case "n": min = (double) int16.MIN;     max = (double) int16.MAX;   break;

            case "q": min = (double) uint16.MIN;    max = (double) uint16.MAX;  break;

            case "i": min = (double) int32.MIN;     max = (double) int32.MAX;   break;

            case "u": min = (double) uint32.MIN;    max = (double) uint32.MAX;  break;

            case "h": min = (double) int32.MIN;     max = (double) int32.MAX;   break;

            default: assert_not_reached ();

        }

    }

    private static double get_variant_as_double (Variant variant)

    {

        switch (variant.classify ())

        {

            case Variant.Class.BYTE:    return (double) variant.get_byte ();

            case Variant.Class.INT16:   return (double) variant.get_int16 ();

            case Variant.Class.UINT16:  return (double) variant.get_uint16 ();

            case Variant.Class.INT32:   return (double) variant.get_int32 ();

            case Variant.Class.UINT32:  return (double) variant.get_uint32 ();

            case Variant.Class.HANDLE:  return (double) variant.get_handle ();

            default: assert_not_reached ();

        }

    }

    public Variant get_variant ()   // TODO test_value against range

    {

        switch (key_type)

        {

            case "y": return new Variant.byte   ((uchar)  get_int64_from_entry ()); // TODO uchar or uint8?

            case "n": return new Variant.int16  ((int16)  get_int64_from_entry ());

            case "q": return new Variant.uint16 ((uint16) get_int64_from_entry ());

            case "i": return new Variant.int32  ((int32)  get_int64_from_entry ());

            case "u": return new Variant.uint32 ((uint32) get_int64_from_entry ()); // TODO also use get_value_as_int?

            case "h": return new Variant.handle ((int32)  get_int64_from_entry ());

            default: assert_not_reached ();

        }

    }

    private int64 get_int64_from_entry ()

    {

        return int64.parse (this.get_text ());

    }

    private void set_lock (bool state)

        requires (deleted_text_handler != 0 && inserted_text_handler != 0)

    {

        if (state)

        {

            SignalHandler.block (buffer, deleted_text_handler);

            SignalHandler.block (buffer, inserted_text_handler);

        }

        else

        {

            SignalHandler.unblock (buffer, deleted_text_handler);

            SignalHandler.unblock (buffer, inserted_text_handler);

        }

    }

    public void reload (Variant gvariant)       // TODO "key_editor_child_number_int_real_reload: assertion 'gvariant != NULL' failed" two times when ghosting a key

    {

        set_lock (true);

        this.set_value (get_variant_as_double (gvariant));

        set_lock (false);

    }

}

private class KeyEditorChildArray : Grid, KeyEditorChild

{

    private TextView text_view;

    private Revealer error_revealer;

    private string key_type;

    private Variant variant;

    private ulong deleted_text_handler = 0;

    private ulong inserted_text_handler = 0;

    construct

    {

        get_style_context ().add_class ("key-editor-child-array");

    }

    public KeyEditorChildArray (string type_string, Variant initial_value)

    {

        this.visible = true;

        this.hexpand = true;

        this.vexpand = false;

        orientation = Orientation.VERTICAL;

        get_style_context ().add_class ("frame");

        this.key_type = type_string;

        this.variant = initial_value;

        ScrolledWindow scrolled_window = new ScrolledWindow (null, null);

        scrolled_window.visible = true;

        text_view = new TextView ();

        text_view.visible = true;

        text_view.expand = true;

        text_view.wrap_mode = WrapMode.WORD;

        text_view.monospace = true;

        text_view.key_press_event.connect ((event) => {

                string keyval_name = (!) (Gdk.keyval_name (event.keyval) ?? "");

                if ((keyval_name == "Return" || keyval_name == "KP_Enter")

                && ((event.state & Gdk.ModifierType.MODIFIER_MASK) == 0)

                && (test_value ()))

                {

                    child_activated ();

                    return true;

                }

                return base.key_press_event (event);

            });

        // https://bugzilla.gnome.org/show_bug.cgi?id=789676

        text_view.button_press_event.connect_after (() => Gdk.EVENT_STOP);

        text_view.button_release_event.connect_after (() => Gdk.EVENT_STOP);

        scrolled_window.add (text_view);

        add (scrolled_window);

        error_revealer = new Revealer ();

        error_revealer.visible = true;

        error_revealer.transition_type = RevealerTransitionType.SLIDE_UP;

        error_revealer.reveal_child = false;

        add (error_revealer);

        ActionBar error_bar = new ActionBar ();

        error_bar.visible = true;

        error_revealer.add (error_bar);

        Image error_icon = new Image.from_icon_name ("dialog-error-symbolic", IconSize.BUTTON);

        error_icon.visible = true;

        error_bar.pack_start (error_icon);

        Label error_label = new Label (_("This value is invalid for the key type."));

        error_label.visible = true;

        error_bar.pack_start (error_label);

        text_view.buffer.text = initial_value.print (false);

        TextBuffer ref_buffer = text_view.buffer;    // an TextBuffer doesn't emit a "destroy" signal

        deleted_text_handler = ref_buffer.delete_range.connect_after (() => value_has_changed (test_value ()));

        inserted_text_handler = ref_buffer.insert_text.connect_after (() => value_has_changed (test_value ()));

        destroy.connect (() => {

                ref_buffer.disconnect (deleted_text_handler);

                ref_buffer.disconnect (inserted_text_handler);

            });

    }

    private bool test_value ()

    {

        string tmp_text = text_view.buffer.text; // don't put in the try{} for correct C code

        try

        {

            Variant? tmp_variant = Variant.parse (new VariantType (key_type), tmp_text);

            variant = (!) tmp_variant;

            StyleContext context = get_style_context ();

            if (context.has_class ("error"))

                context.remove_class ("error");

            error_revealer.reveal_child = false;

            return true;

        }

        catch (VariantParseError e)

        {

            StyleContext context = get_style_context ();

            if (!context.has_class ("error"))

                context.add_class ("error");

            error_revealer.reveal_child = true;

            return false;

        }

    }

    public Variant get_variant ()

    {

        return variant;

    }

    private void set_lock (bool state)

        requires (deleted_text_handler != 0 && inserted_text_handler != 0)

    {

        if (state)

        {

            SignalHandler.block (text_view.buffer, deleted_text_handler);

            SignalHandler.block (text_view.buffer, inserted_text_handler);

        }

        else

        {

            SignalHandler.unblock (text_view.buffer, deleted_text_handler);

            SignalHandler.unblock (text_view.buffer, inserted_text_handler);

        }

    }

    public void reload (Variant gvariant)

    {

        set_lock (true);

        text_view.buffer.text = gvariant.print (false);

        if (!test_value ())

            assert_not_reached ();

        set_lock (false);

    }

}

private class KeyEditorChildDefault : Entry, KeyEditorChild

{

    private string key_type;

    private Variant variant;

    private bool is_string;

    private ulong deleted_text_handler = 0;

    private ulong inserted_text_handler = 0;

    construct

    {

        get_style_context ().add_class ("key-editor-child-entry");

    }

    public KeyEditorChildDefault (string type_string, Variant initial_value)

    {

        this.key_type = type_string;

        this.variant = initial_value;

        this.visible = true;

        this.hexpand = true;

        this.secondary_icon_activatable = false;

        this.set_icon_tooltip_text (EntryIconPosition.SECONDARY, _("This value is invalid for the key type."));

        this.is_string = type_string == "s" || type_string == "o" || type_string == "g";

        this.text = is_string ? initial_value.get_string () : initial_value.print (false);

        EntryBuffer ref_buffer = buffer;    // an EntryBuffer doesn't emit a "destroy" signal

        deleted_text_handler = ref_buffer.deleted_text.connect (() => value_has_changed (test_value ()));

        inserted_text_handler = ref_buffer.inserted_text.connect (() => value_has_changed (test_value ()));

        ulong entry_activate_handler = activate.connect (() => { if (test_value ()) child_activated (); });

        destroy.connect (() => {

                ref_buffer.disconnect (deleted_text_handler);

                ref_buffer.disconnect (inserted_text_handler);

                disconnect (entry_activate_handler);

            });

    }

    private bool test_value ()

    {

        if (key_type == "s")

        {

            variant = new Variant.string (this.text);

            return true;

        }

        string tmp_text = is_string ? @"'$text'" : this.text; // don't put in the try{} for correct C code

        try

        {

            Variant? tmp_variant = Variant.parse (new VariantType (key_type), tmp_text);

            variant = (!) tmp_variant;

            StyleContext context = get_style_context ();

            if (context.has_class ("error"))

                context.remove_class ("error");

            set_icon_from_icon_name (EntryIconPosition.SECONDARY, null);

            return true;

        }

        catch (VariantParseError e)

        {

            StyleContext context = get_style_context ();

            if (!context.has_class ("error"))

                context.add_class ("error");

            secondary_icon_name = "dialog-error-symbolic";

            return false;

        }

    }

    public Variant get_variant ()

    {

        return variant;

    }

    private void set_lock (bool state)

        requires (deleted_text_handler != 0 && inserted_text_handler != 0)

    {

        if (state)

        {

            SignalHandler.block (buffer, deleted_text_handler);

            SignalHandler.block (buffer, inserted_text_handler);

        }

        else

        {

            SignalHandler.unblock (buffer, deleted_text_handler);

            SignalHandler.unblock (buffer, inserted_text_handler);

        }

    }

    public void reload (Variant gvariant)

    {

        set_lock (true);

        this.text = is_string ? gvariant.get_string () : gvariant.print (false);

        if (!test_value ())

            assert_not_reached ();

        set_lock (false);

    }

}