GUI

def section_head(self, s, b = None):
    """
    Create an HTML header for one of the sections in the Start tab.
    """
    header = pn.pane.HTML(f'<h3>{s}</h3>', styles=header_styles)
    return header if b is None else pn.Row(header, b)

def validate_settings(self, _):
    """
    Callback function invoked when the user clicks the Run Optimizer button.
    """
    regions = self.region_boxes.selection()
    budget = self.budget_box.defined()
    targets = self.target_boxes.selection()

    if len(regions) == 0 or (not budget) or len(targets) == 0:
        self.info.show_missing(regions, budget, targets)
        return

    if weights := self.target_boxes.weights():
        if not all([w.isdigit() and (1 <= int(w) <= 5) for w in weights]):
            self.info.show_invalid_weights(weights)
            return

    mapping = self.target_boxes.mapping()

    self.info.show_params(regions, self.budget_box.values(), targets, weights, mapping)

def run_cb(self, _):
    """
    Callback function invoked when the user clicks the Continue button after verifying
    the parameter options.

    Wrap the call to the function that runs the optimizer in code that shows the loading
    icon and opens a message when the function returns.
    """
    try:
        self.close_modal()
        self.main[0].loading = True
        self.run_optimizer()
        self.main[0].loading = False
        self.info.show_success()
    except OPServerError as err:
        self.main[0].loading = False
        self.info.show_fail(err)

def run_optimizer(self):
    """
    Use the settings in the widgets to run OptiPass, save the results
    in the output tab.
    """
    params = [
        self.region_boxes.selection(),
        self.budget_box.values(),
        self.target_boxes.selection(),
        self.target_boxes.weights(),
        self.target_boxes.mapping(),
    ]

    resp = OP.run_optimizer(*params)

    params += resp
    res = OPResult(*params)
    output = OutputPane(res, self.map)

    self.region_boxes.add_external_callback(output.hide_dots)
    self.tabs[3] = ('Output', pn.Column(output, height=self.tab_height, scroll=True))
    self.tabs[4] = ('Download', pn.Column(DownloadPane(res), height=self.tab_height, scroll=True))

def map_help_cb(self, _):
    """
    Callback function for the help button next to the map in the sidebar.
    """
    msg = pn.pane.HTML('''
    <p>When you move your mouse over the map the cursor will change to a "crosshairs" symbol and a set of buttons will appear below the map.
    Navigating with the map is similar to using Google maps or other online maps:</p>
    <ul>
        <li>Left-click and drag to pan (move left and right or up and down).</li>
        <li>If you want to zoom in and out, first click the magnifying glass button below the map; then you can zoom in and out using the scroll wheel on your mouse.</li>   
        <li>Click the refresh button to restore the map to its original size and location.</li>
    </ul>
    ''')
    self.tabs[0].append(pn.layout.FloatPanel(msg, name='Map Controls', contained=False, position='center', width=400))

def region_help_cb(self, _):
    """
    Callback function for the help button next to the region box widget in the start tab.
    """
    msg = pn.pane.HTML('''
    <p>Select a region by clicking in the box to the left of an estuary name.</p>
    <p>Each time you click in a box the map will be updated to show the positions of the barriers that are in our database for the estuary.</p>
    <p>You must select at least one region before you run the optimizer.</p>
    ''')
    self.tabs[2].append(pn.layout.FloatPanel(msg, name='Geographic Regions', contained=False, position='center', width=400))

def budget_help_cb(self, _):
    """
    Callback function for the help button next to the budget box widget in the start tab.
    """
    msg = pn.pane.HTML('''
    <p>There are three ways to specify the budgets used by the optimizer.</p>
    <H4>Basic</H4>
    <p>The simplest method is to specify an upper limit by moving the slider back and forth.  When you use this method, the optimizer will run 10 times, ending at the value you select with the slider.  For example, if you set the slider at $10M (the abbreviation for $10 million), the optimizer will make ROI curves based on budgets of $1M, $2M, <i>etc</i>, up to the maximum of $10M.</p>
    <p>Note that the slider is disabled until you select one or more regions.  That's because the maximum value depends on the costs of the gates in each region.
    For example, the total cost of all gates in the Coquille region is $11.8M.  Once you choose that region, you can move the budget slider
    left and right to pick a maximum budget for the optimizer to consider.
    <H4>Advanced</H4>
    <p>If you click on the Advanced tab in this section you will see ways to specify the budget interval and the number of budgets.</p>
    <p>You can use this method if you want more control over the layout of the ROI curves, for example you can include more points by increasing the number of budgets.</p>
    <H4>Fixed</H4>
    <p>If you know exactly how much money you have to spend you can enter that amount by clicking on the Fixed tab and entering the budget amount.</p>
    <p>The optimizer will run just once, using that budget.  The output will have tables showing the gates identified by the optimizer, but there will be no ROI curve.</p>
    <p>When entering values, you can write the full amount, with or without commas (<i>e.g.</i>11,500,000 or 11500000) or use the abbreviated form (11.5M).</p>
    ''')
    self.tabs[2].append(pn.layout.FloatPanel(msg, name='Budget Levels', contained=False, position='center', width=400))

def target_help_cb(self, _):
    """
    Callback function for the help button next to the target box widget in the start tab.
    """
    msg = pn.pane.HTML('''
    <p>Click boxes next to one or more target names to have the optimizer include those targets in its calculations.</p>
    <p>The optimizer will create an ROI curve for each target selected. </p>
    <p>If more than one target is selected the optimizer will also generate an overall "net benefit" curve based on considering all targets at the same time.</p>
    ''')
    self.tabs[2].append(pn.layout.FloatPanel(msg, name='Targets', contained=False, position='center', width=400))

def climate_help_cb(self, _):
    """
    Callback function for the help button next to the climate scenario checkbox in the start tab.
    """
    msg = pn.pane.HTML('''
    <p>By default the optimizer uses current water levels when computing potential benefits.  Click the button next to <b>Future</b> to have it use water levels expected due to climate change.</p>
    <p>The future scenario uses two projected water levels, both for the period to 2100. For fish habitat targets, the future water level is based on projected sea level rise of 5.0 feet.  For agriculture and infrastructure targets, the future water level is projected to be 7.2 feet, which includes sea level rise and the probabilities of extreme water levels causing flooding events.</p>
    ''')
    self.tabs[2].append(pn.layout.FloatPanel(msg, name='Targets', contained=False, position='center', width=400))

def set_budget_max(self, n: int):
    """
    When the user selects or deselects a region the budget widgets need
    to know the new total cost for all the selected regions.  This method
    passes that information to each of the budget widgets.

    Arguments:
      n: the new maximum budget amount
    """
    for t in self.tabs:
        t.set_budget_max(n)

def values(self):
    """
    Return the budget settings for the currently selected budget type.  Get
    the widget values from the active budget type, convert them into a tuple
    of values that will be passed to the optimizer.

    Returns:
      bmin:  the starting budget
      binc:  the increment between budget values
      bcnt:  the number of budget values 
    """
    return self.tabs[self.tabs.active].values()

def defined(self):
    """
    Return True if the user has defined a budget using the current tab
    """
    return self.tabs[self.tabs.active].defined()

def set_value(self, n):
    """
    Initialize the GUI by setting an initial budget value
    """
    self.tabs[self.tabs.active].set_value(n)

def set_budget_max(self, n):
    """
    Choose a maximum budget by scanning a table of budget levels to
    find the first one less than the total cost.

    Arguments:
      n: the total cost of all barriers in the current selection.
    """
    for i in range(len(self.levels)-1, -1, -1):
        if n >= self.levels[i][1]:
            break
    i = max(i, self.MIN_LEVELS)
    self.slider.options = self.labels[:i+1]

def values(self):
    """
    The basic budget always has the same number of budgets and always
    starts with $0.  Determine the increment by dividing the max budget
    in the slider by the number of budgets.
    """
    x = self.map[self.slider.value]
    return 0, x // self.BUDGET_COUNT, self.BUDGET_COUNT

def defined(self):
    """
    The basic budget is set if the slider is not in the first location.
    """
    return self.slider.value != '$0'

def set_value(self, n):
    """
    Set the slider to n
    """
    self.slider.value = self.slider.options[n]

def values(self):
    """
    A fixed budget has one value, returned as the starting budget.  The 
    the increment is 0 and count is 1.
    """
    s = self.input.value
    if s.startswith('$'):
        s = s[1:]
    n = self.parse_dollar_amount(self.input.value)
    return n, 0, 1

def defined(self):
    """
    The fixed budget is set if the text box is not empty.
    """
    return self.parse_dollar_amount(self.input.value) > 0

def set_value(self, n):
    """
    Initialize the budget to n
    """
    self.input.value = f'${n}'

def parse_dollar_amount(self, s: str):
    """
    Make sure the string entered by the user has an acceptable format.
    It can be all digits (e.g. "1500000"), or digits separated by commas
    (e.g. "1,500,000"), or a number followed by a K or M (e.g. "1.5M").
    There can be a dollar sign at the front of the string.

    Arguments:
      s:  the string entered into the text box

    Returns:
      the value of the string converted into an integer

    """
    try:
        if s.startswith('$'):
            s = s[1:]
        if s.endswith(('K','M')):
            multiplier = 1000 if s.endswith('K') else 1000000
            res = int(float(s[:-1]) * multiplier)
        elif ',' in s:
            parts = s.split(',')
            assert len(parts[0]) <= 3 and (len(parts) == 1 or all(len(p) == 3 for p in parts[1:]))
            res = int(''.join(parts))
        else:
            res = 0 if s == '' else int(s)
        return res
    except Exception:
        return 0

def values(self):
    """
    In this widget the budget increment and budget count are determined
    by the values in the corresponding widgets.
    """
    return 0, self.inc_slider.value, self.count_input.value

def defined(self):
    """
    The advance budget is set if the increment is not 0
    """
    return self.inc_slider.value > 0

def set_value(self, n):
    """
    Set the budget to n
    """
    self.max_slider.value = n

def set_budget_max(self, n):
    """
    Called when the user selects or deselects a region.  Save the new
    maximum, and update the value of the increment based on the new maximum.

    Arguments:
      n:  the total cost of all barriers in the selected regions.
    """
    self.max_slider.end = max(1, n)
    self.max_slider.start = self.MAX_STEP
    self.inc_slider.end = max(1, n // 2)
    self.inc_slider.start = max(self.INC_STEP, n / self.COUNT_MAX)
    lim = 'N/A' if n == 0 else f'${n/1000000:.2f}M'
    self.objects[0][2] = pn.pane.HTML(f'<b>Limit: {lim}</b>')

def max_updated(self, e):
    """
    Callback function invoked when the user moves the maximum budget
    slider.  Computes a new budget increment.
    """
    try:
        self.inc_slider.value = self.max_slider.value // self.count_input.value
    except ArithmeticError:
        pass

def inc_updated(self, e):
    """
    Callback function invoked when the user changes the budget increment.
    Computes a new number of budgets.
    """
    try:
        c = max(self.COUNT_MIN, self.max_slider.value // self.inc_slider.value)
        c = min(self.COUNT_MAX, c)
        self.count_input.value = c
    except ArithmeticError:
        pass

def count_updated(self, e):
    """
    Callback function invoked when the user changes the number of budget
    levels.  Computes a new budget increment.
    """
    try:
        self.inc_slider.value = self.max_slider.value // self.count_input.value
    except ArithmeticError:
        pass

def _make_folder_name(self):
    """
    Use the region names, target names, and budget range to create the default name of the zip file.
    """
    parts = [s[:3] for s in self.op.regions]
    lst = self.op.targets
    if self.op.weights:
        lst = [f'{lst[i]}x{self.op.weights[i]}' for i in range(len(lst))]
    parts.extend(lst)
    parts.append(OP.format_budget_amount(self.op.binc*self.op.bcount)[1:])
    if self.op.mapping:
        parts.append(self.op.mapping)
    return '_'.join(parts)

def _archive_cb(self, e):
    """
    Function called when the user clicks the Download button.  Create the output
    folder and compress it.  When the archive is ready, display a FileDownload
    widget with a button that starts the download.
    """
    if not any([x.value for x in self.boxes.values()]):
        return
    self.loading = True
    base = self._make_archive_dir()
    self._save_files(base)
    p = make_archive(base, 'zip', base)
    self.loading = False
    self[-1] = pn.widgets.FileDownload(file=p, filename=self.filename+'.zip', stylesheets=[button_style_sheet])

def _make_archive_dir(self):
    """
    Create an empty directory for the download, using the name in the form.
    """
    self.filename = self.filename_input.value_input or self.filename_input.value
    archive_dir = Path.cwd() / 'tmp' / self.filename
    if Path.exists(archive_dir):
        rmtree(archive_dir)
    Path.mkdir(archive_dir)
    return archive_dir

def _save_files(self, loc):
    """
    Write the tables and figures to the download directory.

    Arguments:
      loc:  the path to the directory.
    """
    figures = self.op.display_figures if self.image_type.value == 'HTML' else self.op.download_figures
    for name, fig in figures:
        if name == 'Net' and not self.boxes[self.NB].value:
            continue
        if name != 'Net' and not self.boxes[self.IT].value:
            continue
        if self.image_type.value == 'HTML':
            savehtml(fig, filename=loc/f'{name}.html')
        else:
            ext = self.image_type.value.lower()
            fn = loc/f'{name}.{ext}'
            fig.savefig(fn, bbox_inches='tight')
    if self.boxes[self.BS].value:
        df = self.op.summary.drop(['gates'], axis=1)
        df.to_csv(
            loc/'budget_summary.csv', 
            index=False,
            float_format=lambda n: round(n,2)
        )
    if self.boxes[self.BD].value:
        self.op.matrix.to_csv(
            loc/'barrier_details.csv',
            index=False,
            float_format=lambda n: round(n,2)
        )

def _cancel_cb(self, _):
    """
    Close the dialog when the user clicks the "Cancel" button.
    """
    self.template.close_modal()

def show_missing(self, rlist, budget, tlist):
    """
    Method called by the OP class when it detects missing parameters (e.g.
    if the user did not select a region or a target).
    """
    text = self.missing_params_text
    if len(rlist) == 0:
        text += ' * one or more geographic regions\n'
    if not budget:
        text += ' * a maximum budget\n'
    if len(tlist) == 0:
        text += ' * one or more targets\n'
    self.clear()
    self.append(pn.pane.Alert(text, alert_type = 'warning'))
    self.template.open_modal()

def show_invalid_weights(self, w: list[str]):
    """
    Method called when weighted targets are being used and one of the
    text boxes does not have a valid entry (must be a number between 1 and 5).

    Arguments:
      w: the list of strings read from the text entry widgets
    """
    text = self.invalid_weights_text.format(w)
    self.clear()
    self.append(pn.pane.Alert(text, alert_type = 'warning'))
    self.template.open_modal()

def show_params(self, regions, budgets, targets, weights, mapping):
    """
    Method called to allow the user to review the optimization parameters read from the
    various widgets.  Displays each parameter and two buttons ("Cancel" and "Continue").

    Arguments:
      regions:  list of region names
      budgets:  a tuple with starting budget, increment, and count
      targets:  list of restoration target names
      weights:  list of target weights (optional)
      mapping:  column mappings (optional)
    """
    bstart, binc, bcount = budgets
    fbmax = OP.format_budget_amount(binc*bcount)
    fbstep = OP.format_budget_amount(binc)
    fbstart = OP.format_budget_amount(bstart)
    text = self.preview_message_text
    text += f'  * Regions: {", ".join(regions)}\n\n'
    if bcount > 1:
        text += f'  * {bcount} budget levels from {fbstep} up to {fbmax} in increments of {fbstep}\n\n'
    else:
        text += f'  * a single budget of {fbstart}\n\n'
    targets = [t.split(':')[-1] for t in targets]
    if weights:
        targets = [f'{targets[i]} ⨉ {weights[i]}' for i in range(len(targets))]
    text += f'  * Targets: {", ".join(targets)}\n' 
    text += f'  * Mapping: {mapping}\n\n'
    self.clear()
    self.append(pn.pane.Alert(text, alert_type = 'secondary'))
    self.append(pn.Row(self.cancel_button, self.continue_button))
    self.template.open_modal()

def show_success(self):
    """
    Method called after OptiPass has finished running and the results have been
    parsed successfully.
    """
    self.clear()
    self.append(pn.pane.Alert(self.success_text, alert_type = 'success'))
    self.template.open_modal()

def show_fail(self, reason):
    """
    Method called if OptiPass failed.

    Arguments:
      reason:  string containing the error message
    """
    self.clear()
    text = self.fail_text.format(reason)
    if str(reason) == 'No solution':
        text += '\n * try increasing the maximum budget'
    self.append(pn.pane.Alert(text, alert_type = 'danger'))
    self.template.open_modal()

def _make_title(self, op):
    """
    The top section of the output pane is a title showing the optimization parameters.
    """
    tnames = [OP.target_frame.loc[t].short for t in op.targets]
    if op.weights:
        tnames = [f'{tnames[i]} ⨉ {op.weights[i]}' for i in range(len(tnames))]

    title = f"<p><b>Regions:</b> {', '.join(op.regions)};"
    title += f" <b>Targets:</b> {', '.join(tnames)};"
    if s := OP.mapping_name:
        title += f" <b>{s.capitalize()}:</b> {op.mapping};"
    if op.bcount > 1:
        bmax = op.binc * op.bcount
        smin = OP.format_budget_amount(op.binc)
        smax = OP.format_budget_amount(bmax)
        title += f" <b>Budgets:</b> {smin} to {smax}</p>"
    else:
        b = OP.format_budget_amount(op.bmin),
        title += " <b>Budget:</b> {b}</p>"
    return pn.pane.HTML(title)

def _make_figures_tab(self, op):
    """
    Create a Tabs object with one tab for each ROI curve.
    """
    tabs = pn.Tabs(
        tabs_location='left',
        stylesheets = [output_tab_style_sheet],
    )
    op.make_roi_curves()
    for p in op.display_figures:
        tabs.append(p)
    return tabs

def _make_budget_table(self, op, tgmap):
    """
    Make the table of benefits for each budget.  Attach
    a callback function that is called when the user clicks on a row
    in the table (the callback updates the map to show gates used in a
    solution).
    """
    df = op.budget_table()
    formatters = { col: NumberFormatter(format='0.0', text_align='center') for col in df.columns }
    formatters['Budget'] = {'type': 'money', 'symbol': '$', 'precision': 0}
    formatters['# Barriers'] = NumberFormatter(format='0', text_align='center')
    alignment = { 
        'Budget': 'right',
        'Net Gain': 'center',
        '# Barriers': 'center'
    }

    table = pn.widgets.Tabulator(
        df,
        show_index = False,
        hidden_columns = ['gates'],
        editors = { c: None for c in df.columns },
        text_align = alignment,
        header_align = {c: 'center' for c in df.columns},
        formatters = formatters,
        selectable = True,
        configuration = {'columnDefaults': {'headerSort': False}},
    )
    self.budget_table = df
    self.make_dots(table, op, tgmap)
    table.on_click(self.budget_table_cb)

    return table

def _make_gate_table(self, op):
    """
    Make a table showing details about gates used in solutions.
    """
    formatters = { }
    alignment = { }
    df = op.gate_table()

    df.columns = [OP.format_budget_amount(int(s)) if s.isdigit() else s for s in df.columns]

    for col in df.columns:
        if col.startswith('$') or col in ['Primary','Dominant']:
            formatters[col] = {'type': 'tickCross', 'crossElement': ''}
            alignment[col] = 'center'
        elif col == 'Cost':
            formatters[col] = {'type': 'money', 'symbol': '$', 'precision': 0}
            alignment[col] = 'right'

    table = pn.widgets.Tabulator(
        df, 
        show_index=True, 
        frozen_columns=['ID'],
        hidden_columns=['count'],
        formatters=formatters,
        text_align=alignment,
        configuration={'columnDefaults': {'headerSort': False}},
        header_align={c: 'center' for c in df.columns},
        selectable = False,
    )
    table.disabled = True
    self.gate_table = df
    return table

def make_dots(self, plot, op, tgmap):
    """
    Called after the output panel is initialized, make a set of glyphs to display
    for each budget level.
    """
    self.selected_row = None
    self.dots = []
    for name, row in self.budget_table.iterrows():
        df = tgmap.map_coords().loc[row.gates]
        c = tgmap.map.circle_dot('x', 'y', size=12, line_color='blue', fill_color='white', source=df)
        c.visible = False
        self.dots.append(c)

def budget_table_cb(self, e):
    """
    The callback function invoked when the user clicks a row in the budget table.
    Use the event to figure out which row was clicked.  Hide any dots that were displayed
    previously, then make the dots for the selected row visible.
    """
    if n := self.selected_row:
        self.dots[n].visible = False
    self.selected_row = e.row
    self.dots[self.selected_row].visible = True

def hide_dots(self):
    """
    Callback function invoked when users click on a region name in the start panel to hide
    any dots that might be on the map.
    """
    if self.selected_row:
        self.dots[self.selected_row].visible = False
    self.selected_row = None

def cb(self, *events):
    """
    Callback function invoked when one of the checkboxes is clicked.  If the new state
    of the checkbox is 'selected' the region is added to the set of selected regions,
    otherwise it is removed.  After updating the set notify the map widget and any
    other widgets that have been registered as external callbacks.
    """
    for e in events:
        if e.type == 'changed':
            r = e.obj.name
            if e.new:
                self.selected.add(r)
            else:
                self.selected.remove(r)
            amount = sum(OP.total_cost[x] for x in self.selected)
            self.budget_box.set_budget_max(amount)
    self.map.display_regions(self.selected)
    # self.map.zoom(self.selected)
    if self.external_cb:
        self.external_cb()

def check(self, region):
    """
    Initialize the box by addidng region to the selection.
    """
    self.boxes[region].value = True

def selection(self) -> list[str]:
    """
    Return a list of the names of currently selected regions.
    """
    return list(self.selected)

def add_external_callback(self, f):
    """
    Save a reference to an external function to call when a region box is clicked.

    Arguments:
      f: aditional function to call when a checkbox is clicked
    """
    self.external_cb = f