"""Home menu configuration through the shared widget-style manager."""
import copy
import json
import os
import re
import tempfile
import xml.etree.ElementTree as ET

import xbmc
import xbmcaddon
import xbmcgui
import xbmcvfs

from wcs.skin import compose, family, menu_order, modular
from wcs.skin.context_dialogs import Menu, MenuManager

ADDON_ID = 'plugin.video.milionar'


def catalog(addon):
    root = ET.parse(os.path.join(xbmcvfs.translatePath(addon.getAddonInfo('path')), 'resources', 'skin.milionar', 'xml', 'Home.xml')).getroot()
    return {item.findtext("property[@name='id']"): {
        'label': xbmc.getInfoLabel(item.findtext('label')),
        'flag': re.search(r'!Skin\.HasSetting\(([^)]+)\)', item.findtext('visible')).group(1),
    } for item in menu_order.content(root).findall('item')}


class HomeMenu(Menu):
    header = column = 35717
    to_main, to_more, defaults_label = 35718, 35719, 35720
    more_edits = True
    status_column = 35723
    groups = {'main': 35715, 'more': 32420, 'hidden': 35716}

    def __init__(self, items):
        self.items = items
        self.hidden = {key for key, item in items.items() if xbmc.getCondVisibility('Skin.HasSetting({})'.format(item['flag']))}

    def label(self, row, action):
        return self.items[action]['label']

    def reset(self, row, config):
        return {group: [key for key in self.items if key in config[group]] for group in ('main', 'more', 'hidden')}

    def normalize(self, row, config):
        hidden = [key for key in config['hidden'] if key in self.items]
        ordered = menu_order.normalize(config['main'] + hidden, self.items)
        return {'main': [key for key in ordered if key not in hidden], 'more': [], 'hidden': hidden}


class HomeMenuManager(MenuManager):
    def __init__(self, *args, **kwargs):
        self.selected = kwargs.pop('selected', None)
        self.command = None
        super().__init__(*args, **kwargs)

    def onInit(self):
        super().onInit()
        if self.selected:
            self.getControl(9000).selectItem(next((i for i, entry in enumerate(self.entries) if entry[1] == self.selected), 0))

    def onClick(self, control_id):
        if control_id in (9000, 9104):
            index = self.getControl(9000).getSelectedPosition()
            if 0 <= index < len(self.entries):
                self.command = self.entries[index][1]
                self.close()
            return
        super().onClick(control_id)


def _write_home(addon, order):
    """Apply only Home.xml atomically; all later installs use the identical composition."""
    from wcs.skin import installer
    folder = installer.target_dir()
    if os.path.islink(folder):
        raise OSError('refusing to overwrite a source skin symlink')
    resources = os.path.join(xbmcvfs.translatePath(addon.getAddonInfo('path')), 'resources')
    entry = modular.plan(resources, *modular.choices(addon), order=order)[os.path.join('xml', 'Home.xml')]
    data = compose.read(entry)
    path = os.path.join(folder, 'xml', 'Home.xml')
    with open(path, 'rb') as handle:
        if handle.read() == data:
            return False
    temporary = None
    try:
        with tempfile.NamedTemporaryFile(dir=os.path.dirname(path), prefix='.Home-', delete=False) as handle:
            temporary = handle.name
            handle.write(data)
        os.replace(temporary, path)
    finally:
        if temporary and os.path.exists(temporary):
            os.unlink(temporary)
    return True


def commit(addon, items, config, original):
    if config == original:
        return
    order = json.dumps(config['main'] + config['hidden'], separators=(',', ':'))
    previous = addon.getSetting(menu_order.SETTING)
    changed = _write_home(addon, order)
    addon.setSetting(menu_order.SETTING, order)
    if addon.getSetting(menu_order.SETTING) != order:
        _write_home(addon, previous)
        raise OSError('menu preference was not saved')
    for key, item in items.items():
        hidden = key in config['hidden']
        if hidden != (key in original['hidden']):
            xbmc.executebuiltin('Skin.{}({})'.format('SetBool' if hidden else 'Reset', item['flag']), True)
    if changed:
        xbmc.executebuiltin('ReloadSkin()', True)


def edit():
    if not family.active():
        return
    addon = xbmcaddon.Addon(ADDON_ID)
    items = catalog(addon)
    model = HomeMenu(items)
    order = menu_order.normalize(addon.getSetting(menu_order.SETTING), items)
    original = {'main': [key for key in order if key not in model.hidden], 'more': [],
                'hidden': [key for key in order if key in model.hidden]}
    config, selected = copy.deepcopy(original), None
    while not xbmc.Monitor().abortRequested():
        dialog = HomeMenuManager('skin/DialogMilionarContextManager.xml', addon.getAddonInfo('path'),
                                 'Default', '1080i', row='home', config=config, model=model,
                                 title=addon.getLocalizedString(35717), selected=selected)
        dialog.original = copy.deepcopy(original)
        dialog.doModal()
        result, config, selected = dialog.result, dialog.config, dialog.command
        del dialog
        if result is not None:
            try:
                commit(addon, items, result, original)
            except OSError as exc:
                xbmc.log('[Milionář Menu] save failed: ' + type(exc).__name__, xbmc.LOGERROR)
                xbmcgui.Dialog().notification('Milionář', addon.getLocalizedString(35721), xbmcgui.NOTIFICATION_ERROR)
            return
        if selected is None:
            return
        # Keep the same editor draft and row across the existing native widget manager.
        from wcs.skin.slots import open_for_menu_item
        from wcs.skin.picker import _child_finished
        open_for_menu_item(selected)
        _child_finished()
