import sims4.commands
import sims.sim_info
import services
from sims4.localization import LocalizationHelperTuning
from ui.ui_dialog_picker import SimPickerRow, UiSimPicker
import sims4.collections

@sims4.commands.Command('pickertest', command_type=sims4.commands.CommandType.Live)
def sim_picker_dialog_test(_connection=None):
    output = sims4.commands.CheatOutput(_connection)
    client = services.client_manager().get_first_client()

    def get_inputs_callback(dialog):
        if not dialog.accepted:
            output("Dialog was closed/cancelled")
            return
        output("Dialog was accepted")
        for sim_id in dialog.get_result_tags():
            output("id={}".format(sim_id))

    localized_title = lambda **_: LocalizationHelperTuning.get_raw_text("Sim Picker Dialog Test")
    localized_text = lambda **_: LocalizationHelperTuning.get_raw_text("Select up to five sims and press OK or close dialog....")
    max_selectable_immutable = sims4.collections.make_immutable_slots_class(set(['multi_select', 'number_selectable', 'max_type']))
    max_selectable = max_selectable_immutable({'multi_select':False, 'number_selectable':5, 'max_type':1})
    dialog = UiSimPicker.TunableFactory().default(client.active_sim, text=localized_text, title=localized_title, max_selectable=max_selectable, min_selectable=1, should_show_names=True, hide_row_description=False)
    for sim_info in services.sim_info_manager().get_all():
        # Set second arg below to True to have that sim preselected/highlighted....
        dialog.add_row(SimPickerRow(sim_info.sim_id, False, tag=sim_info.sim_id))
    dialog.add_listener(get_inputs_callback)
    dialog.show_dialog(icon_override=(None, sim_info))

import injector
import services
import traceback
from server_commands.argument_helpers import\
    OptionalTargetParam, get_optional_target
from sims4.localization import LocalizationHelperTuning
from ui.ui_dialog import ButtonType, UiDialog, UiDialogResponse
import ui.ui_dialog_service

class UiDialogChoicesInput(UiDialog):
    __qualname__ = 'UiDialogChoicesInput'
    CHOICES_LOWEST_ID = 20000

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._choice_responses = list()

    def _get_responses_gen(self):
        # yield old values:
        super_results = list(super()._get_responses_gen())
        for result in super_results:
            yield result
        # yield our choices:
        for response in self._choice_responses:
            yield response

shown_choices_dlg = None

@injector.inject_to(ui.ui_dialog_service.UiDialogService, "dialog_respond")
def display_choices_dialog_respond_hook(original, self, *args, **kwargs):
    try:
        dialog = self._active_dialogs.get(\
            args[0], None)

        global shown_choices_dlg
        if shown_choices_dlg != None:
            dlg = shown_choices_dlg
            shown_choices_dlg = None
            dlg.respond(args[1])
            return True

        # regular handling of other dialogs:
        result = original(self, *args, **kwargs)
        return result
    except Exception as e:
        print("INTERNAL ERROR ON RESPOND: " + str(e))
        print(traceback.format_exc())

def display_choices(choices, choice_callback, title="Choose...", \
        text="Please make a choice", icon_sim=None):
    global shown_choices_dlg

    # create dialog:
    client = services.client_manager().get_first_client()
    dlg = UiDialogChoicesInput.TunableFactory().\
        default(
        client.active_sim,
        text=lambda **_: LocalizationHelperTuning.get_raw_text(text),
        title=lambda **_: LocalizationHelperTuning.get_raw_text(title)
        )

    # add choices:
    choice_id = dlg.CHOICES_LOWEST_ID
    i = 0
    while i < len(choices):  # NOT a for loop to require indexing to work
        choice = choices[i]
        dlg._choice_responses.append(\
            UiDialogResponse(dialog_response_id=choice_id,
                text=lambda _txt=choice, **_: \
                    LocalizationHelperTuning.get_raw_text(\
                    _txt),\
                ui_request=UiDialogResponse.UiDialogUiRequest.NO_REQUEST))
        choice_id += 1
        i += 1
    # default cancel choice:
    dlg._choice_responses.append(\
        UiDialogResponse(dialog_response_id=ButtonType.DIALOG_RESPONSE_CANCEL,\
            text=lambda **_: LocalizationHelperTuning.get_raw_text(\
                "Cancel"),\
            ui_request=UiDialogResponse.UiDialogUiRequest.NO_REQUEST))

    # response handler calling the choice_callback of the user:
    def response_func(dialog):
        try:
            if dialog.accepted:
                try:
                    choice_callback(choices[dialog.response - \
                        dlg.CHOICES_LOWEST_ID])
                except IndexError:
                    choice_callback(None)
            else:
                choice_callback(None)
        except Exception as e:
            print("[maybecats choices] error in choice_callback: " + str(e))
            print(traceback.format_exc())
            raise e  # propagate error

    # show dialog:
    dlg.add_listener(response_func)
    if icon_sim == None:
        icon_sim = client.active_sim
    shown_choices_dlg = dlg
    dlg.show_dialog(icon_override=(None, icon_sim))
 

from maybecats_choices import display_choices

def show_my_choices():
    def handle_result(result):
        if result == None:
            print("The user clicked cancel!"
        elif result == "Choice A":
            print("The user picked A")
        elif result == "Choice B":
            print("The user picked B")
    display_choices(["Choice A", "Choice B"], handle_result, text="So you gotta pick A or B....", title="Life Decision!")

    # show dialog:
    dlg.add_listener(response_func)
    if icon_sim == None:
        icon_sim = client.active_sim
    #shown_choices_dlg = dlg
    dlg_service = services.ui_dialog_service()
    dlg_service._active_dialogs[dlg.dialog_id] = dlg
    dlg.show_dialog(icon_override=(None, icon_sim))