#!/usr/bin/python3
#
# Copyright (C) 2022 Canonical, Ltd.
# Author: Lukas Märdian <slyon@ubuntu.com>
#
# This program 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; version 3.
#
# This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.

'''netplan status command line'''

import json
import logging
import re
from netplan.netdef import NetplanRoute

import yaml

from .. import utils
from ..state import NetplanConfigState, SystemConfigState, JSON
from ..state_diff import DiffJSONEncoder, NetplanDiffState


MATCH_TAGS = re.compile(r'\[([a-z0-9]+)\].*\[\/\1\]')
RICH_OUTPUT = False
try:
    from rich.console import Console
    from rich.highlighter import RegexHighlighter
    from rich.theme import Theme

    class NetplanHighlighter(RegexHighlighter):
        base_style = 'netplan.'
        highlights = [
            r'(^|[\s\/])(?P<int>\d+)([\s:]?\s|$)',
            r'(?P<str>(\"|\').+(\"|\'))',
            ]
    RICH_OUTPUT = True
except ImportError:  # pragma: nocover (we mock RICH_OUTPUT, ignore the logging)
    logging.debug("python3-rich not found, falling back to plain output")


class NetplanStatus(utils.NetplanCommand):
    def __init__(self):
        super().__init__(command_id='status',
                         description='Query networking state of the running system',
                         leaf=True)
        self.all = False
        self.state_diff = None
        self.route_lookup_table_names = {}

    def run(self):
        self.parser.add_argument('ifname', nargs='?', type=str, default=None,
                                 help='Show only this interface')
        self.parser.add_argument('-a', '--all', action='store_true',
                                 help='Show all interface data (incl. inactive)')
        self.parser.add_argument('-v', '--verbose', action='store_true',
                                 help='Show extra information')
        self.parser.add_argument('-f', '--format', default='tabular',
                                 help='Output in machine readable `json` or `yaml` format')
        self.parser.add_argument('--diff', action='store_true',
                                 help='Show the differences between the system\'s and netplan\'s states')
        self.parser.add_argument('--diff-only', action='store_true',
                                 help='Only show the differences between the system\'s and netplan\'s states')
        self.parser.add_argument('--root-dir',
                                 help='Search for configuration files in this root directory instead of /')

        self.func = self.command
        self.parse_args()
        self.run_command()

    def _create_pretty_print(self, _console_width):
        if RICH_OUTPUT:
            # TODO: Use a proper (subiquity?) color palette
            theme = Theme({
                'netplan.int': 'bold cyan',
                'netplan.str': 'yellow',
                'muted': 'grey62',
                'online': 'green bold',
                'offline': 'red bold',
                'unknown': 'yellow bold',
                'highlight': 'bold'
                })
            if self.diff:
                theme = Theme({
                    'netplan.int': 'grey62',
                    'netplan.str': 'grey62',
                    'muted': 'grey62',
                    'online': 'green bold',
                    'offline': 'red bold',
                    'unknown': 'yellow bold',
                    'highlight': 'bold'
                    })

            console = Console(highlighter=NetplanHighlighter(), theme=theme,
                              width=_console_width, emoji=False)
            pprint = console.print
        else:
            pprint = self.plain_print

        return pprint

    def _get_interface_diff(self, ifname) -> dict:
        if self.state_diff:
            if diff := self.state_diff['interfaces'].get(ifname):
                if diff.get('system_state') or diff.get('netplan_state'):
                    return diff
        return {}

    def _is_interface_missing_in_netplan(self, ifname) -> bool:
        if self.state_diff:
            if missing := self.state_diff.get('missing_interfaces_netplan'):
                if ifname in missing:
                    return True
        return False

    def _get_missing_property_list(self, ifname: str, state: str, property: str) -> list[str]:
        if self.state_diff:
            if diff := self.state_diff['interfaces'].get(ifname):
                return diff.get(state, {}).get(property, [])
        return []

    def _get_missing_property_str(self, ifname: str, state: str, property: str) -> str:
        if self.state_diff:
            if diff := self.state_diff['interfaces'].get(ifname):
                return diff.get(state, {}).get(property, '')
        return ''

    def _get_missing_property_set(self, ifname: str, state: str, property: str) -> set:
        if self.state_diff:
            if diff := self.state_diff['interfaces'].get(ifname):
                return diff.get(state, {}).get(property, set())
        return set()

    def _get_missing_property_bool(self, ifname: str, state: str, property: str) -> bool:
        if self.state_diff:
            if diff := self.state_diff['interfaces'].get(ifname):
                return diff.get(state, {}).get(property, False)
        return False

    def _get_missing_netplan_addresses(self, ifname) -> list[str]:
        return self._get_missing_property_list(ifname, 'netplan_state', 'missing_addresses')

    def _get_missing_system_nameservers(self, ifname) -> list[str]:
        return self._get_missing_property_list(ifname, 'system_state', 'missing_nameservers_addresses')

    def _get_missing_netplan_nameservers(self, ifname) -> list[str]:
        return self._get_missing_property_list(ifname, 'netplan_state', 'missing_nameservers_addresses')

    def _get_missing_netplan_search(self, ifname) -> list[str]:
        return self._get_missing_property_list(ifname, 'netplan_state', 'missing_nameservers_search')

    def _get_missing_system_search(self, ifname) -> list[str]:
        return self._get_missing_property_list(ifname, 'system_state', 'missing_nameservers_search')

    def _get_missing_system_macaddress(self, ifname) -> str:
        return self._get_missing_property_str(ifname, 'system_state', 'missing_macaddress')

    def _get_missing_netplan_routes(self, ifname) -> set[NetplanRoute]:
        return self._get_missing_property_set(ifname, 'netplan_state', 'missing_routes')

    def _get_missing_system_routes(self, ifname) -> set[NetplanRoute]:
        return self._get_missing_property_set(ifname, 'system_state', 'missing_routes')

    def _is_missing_dhcp4_address(self, ifname) -> bool:
        return self._get_missing_property_bool(ifname, 'system_state', 'missing_dhcp4_address')

    def _is_missing_dhcp6_address(self, ifname) -> bool:
        return self._get_missing_property_bool(ifname, 'system_state', 'missing_dhcp6_address')

    def _get_missing_system_bond_link(self, ifname) -> str:
        return self._get_missing_property_str(ifname, 'system_state', 'missing_bond_link')

    def _get_missing_netplan_bond_link(self, ifname) -> str:
        return self._get_missing_property_str(ifname, 'netplan_state', 'missing_bond_link')

    def _get_missing_system_bridge_link(self, ifname) -> str:
        return self._get_missing_property_str(ifname, 'system_state', 'missing_bridge_link')

    def _get_missing_netplan_bridge_link(self, ifname) -> str:
        return self._get_missing_property_str(ifname, 'netplan_state', 'missing_bridge_link')

    def _get_missing_system_vrf_link(self, ifname) -> str:
        return self._get_missing_property_str(ifname, 'system_state', 'missing_vrf_link')

    def _get_missing_netplan_vrf_link(self, ifname) -> str:
        return self._get_missing_property_str(ifname, 'netplan_state', 'missing_vrf_link')

    def _get_missing_netplan_members(self, ifname) -> list[str]:
        return self._get_missing_property_list(ifname, 'netplan_state', 'missing_interfaces')

    def _get_missing_system_members(self, ifname) -> list[str]:
        return self._get_missing_property_list(ifname, 'system_state', 'missing_interfaces')

    def _get_missing_system_interfaces(self) -> dict:
        if self.state_diff:
            return self.state_diff.get('missing_interfaces_system', {})
        return {}

    def _has_diff(self, ifname) -> bool:
        if self._is_interface_missing_in_netplan(ifname):
            return True
        if self.state_diff:
            if diff := self.state_diff['interfaces'].get(ifname):
                if diff.get('system_state') or diff.get('netplan_state'):
                    return True
        return False

    def _display_global_state(self, data):
        global_state = data.get('netplan-global-state', {})
        self.pprint(('{title:>'+self.PAD+'} {value}').format(
            title='Online state:',
            value='[online]online[/online]' if global_state.get('online', False) else '[offline]offline[/offline]',
            ))
        ns = global_state.get('nameservers', {})
        dns_addr: list = ns.get('addresses', [])
        dns_mode: str = ns.get('mode')
        dns_search: list = ns.get('search', [])
        if dns_addr:
            for i, val in enumerate(dns_addr):
                self.pprint(('{title:>'+self.PAD+'} {value}[muted]{mode}[/muted]').format(
                    title='DNS Addresses:' if i == 0 else '',
                    value=val,
                    mode=' ({})'.format(dns_mode) if dns_mode else '',
                    ))
        if dns_search:
            for i, val in enumerate(dns_search):
                self.pprint(('{title:>'+self.PAD+'} {value}').format(
                    title='DNS Search:' if i == 0 else '',
                    value=val,
                    ))
        self.pprint()

    def _display_interface_header(self, ifname: str, data):
        state = data.get('operstate', 'UNKNOWN') + '/' + data.get('adminstate', 'UNKNOWN')
        scolor = 'unknown'
        if state == 'UP/UP':
            state = 'UP'
            scolor = 'online'
        elif state == 'DOWN/DOWN':
            state = 'DOWN'
            scolor = 'offline'
        full_type = data.get('type', 'other')
        ssid = data.get('ssid')
        tunnel_mode = data.get('tunnel_mode')
        if full_type == 'wifi' and ssid:
            full_type += ('/"' + ssid + '"')
        elif full_type == 'tunnel' and tunnel_mode:
            full_type += ('/' + tunnel_mode)

        format = '[{col}]●[/{col}] {idx:>2}: {name} {type} [{col}]{state}[/{col}] ({backend}{netdef})'
        netdef = ': [highlight]{}[/highlight]'.format(data.get('id')) if data.get('id') else ''
        extra = ''
        sign = ''
        if self.diff:
            if self._is_interface_missing_in_netplan(ifname):
                sign = self.PLUS
                format = '{sign} [{col}]●[/{col}] {idx:>2}: [green][highlight]{name} {type}'
                format += ' [{col}]{state}[/{col}] ({backend}{netdef})[/highlight][/green]'
            else:
                format = '  [muted]● {idx:>2}: {name} {type} {state} ({backend}{netdef})[/muted]'
                netdef = ': {}'.format(data.get('id')) if data.get('id') else ''

        if not self.diff_only or self._has_diff(ifname):
            self.pprint(format.format(
                sign=sign,
                col=scolor,
                idx=data.get('index', '?'),
                name=ifname,
                type=full_type,
                state=state,
                backend=data.get('backend', 'unmanaged'),
                netdef=netdef,
                extra=extra,
                ))

    def _display_mac_address(self, ifname: str, data):
        if macaddress := data.get('macaddress'):
            hide_macaddress = False
            missing_system_macaddress = self._get_missing_system_macaddress(ifname)
            format = '{title:>'+self.PAD+'} {mac}[muted]{vendor}[/muted]'
            sign = ''
            if self.diff and not missing_system_macaddress:
                format = '  [muted]{title:>'+self.PAD+'} {mac}{vendor}[/muted]'
                if self.diff_only:
                    hide_macaddress = True
            elif self.diff and missing_system_macaddress:
                sign = self.PLUS
                format = '{sign} {title:>'+self.PAD+'} [green][highlight]{mac}{vendor}[/highlight][/green]'

            if not hide_macaddress:
                self.pprint((format).format(
                    sign=sign,
                    title='MAC Address:',
                    mac=macaddress,
                    vendor=' ({})'.format(data.get('vendor', '')) if data.get('vendor') else '',
                    ))

                if self.diff and missing_system_macaddress:
                    sign = self.MINUS
                    format = '{sign} {title:>'+self.PAD+'} [red][highlight]{mac}{vendor}[/highlight][/red]'
                    self.pprint((format).format(
                        sign=sign,
                        title='',
                        mac=missing_system_macaddress,
                        vendor=' ({})'.format(data.get('vendor', '')) if data.get('vendor') else '',
                        ))

    def _display_ip_addresses(self, ifname: str, data):
        lst: list = data.get('addresses', [])
        addresses_displayed = 0
        if lst:
            missing_netplan_addresses = self._get_missing_netplan_addresses(ifname)
            for obj in lst:
                sign = ''
                hide_address = False
                ip, extra = list(obj.items())[0]  # get first (and only) address
                prefix = extra.get('prefix', '')
                flags = []
                if extra.get('flags'):  # flags
                    flags = extra.get('flags', [])
                highlight_start = ''
                highlight_end = ''
                if not flags or 'dhcp' in flags:
                    highlight_start = '[highlight]'
                    highlight_end = '[/highlight]'

                address = f'{ip}/{prefix}'
                if self.diff and address not in missing_netplan_addresses:
                    format = '  [muted]{title:>'+self.PAD+'} {start}{ip}/{prefix}{end}{extra}[/muted]'
                    highlight_start = ''
                    highlight_end = ''
                    if self.diff_only:
                        hide_address = True
                elif self.diff and address in missing_netplan_addresses:
                    sign = self.PLUS
                    format = '{sign} {title:>'+self.PAD+'} [green]{start}{ip}/{prefix}{extra}{end}[/green]'
                    highlight_start = '[highlight]'
                    highlight_end = '[/highlight]'
                else:
                    format = '{title:>'+self.PAD+'} {start}{ip}/{prefix}{end}[muted]{extra}[/muted]'

                if not hide_address:
                    self.pprint((format).format(
                        sign=sign,
                        title='Addresses:' if addresses_displayed == 0 else '',
                        ip=ip,
                        prefix=prefix,
                        extra=' ('+', '.join(flags)+')' if flags else '',
                        start=highlight_start,
                        end=highlight_end,
                        ))
                    addresses_displayed += 1

        if diff := self._get_interface_diff(ifname):
            sign = self.MINUS
            if missing_addresses := diff.get('system_state', {}).get('missing_addresses'):
                for ip in missing_addresses:
                    self.pprint(('{sign} {title:>'+self.PAD+'} [highlight][red]{ip}[/red][/highlight]').format(
                        sign=sign,
                        title='Addresses:' if addresses_displayed == 0 else '',
                        ip=ip,
                        ))
                    addresses_displayed += 1
            if self._is_missing_dhcp4_address(ifname):
                self.pprint(('{sign} {title:>'+self.PAD+'} [highlight][red]0.0.0.0/0 (dhcp)[/red][/highlight]').format(
                    sign=sign,
                    title='Addresses:' if addresses_displayed == 0 else '',
                    ))
                addresses_displayed += 1
            if self._is_missing_dhcp6_address(ifname):
                self.pprint(('{sign} {title:>'+self.PAD+'} [highlight][red]::/0 (dhcp)[/red][/highlight]').format(
                    sign=sign,
                    title='Addresses:' if addresses_displayed == 0 else '',
                    ))

    def _display_dns_addresses(self, ifname: str, data):
        lst = data.get('dns_addresses', [])
        nameservers_displayed = 0
        if lst:
            missing_netplan_nameservers = self._get_missing_netplan_nameservers(ifname)
            for val in lst:
                sign = ''
                hide_nameserver = False
                if self.diff and val not in missing_netplan_nameservers:
                    format = '  [muted]{title:>'+self.PAD+'} {value}[/muted]'
                    highlight_start = ''
                    highlight_end = ''
                    if self.diff_only:
                        hide_nameserver = True
                elif self.diff and val in missing_netplan_nameservers:
                    sign = self.PLUS
                    format = '{sign} {title:>'+self.PAD+'} [green]{start}{value}{end}[/green]'
                    highlight_start = '[highlight]'
                    highlight_end = '[/highlight]'
                else:
                    format = '{title:>'+self.PAD+'} {value}'
                    highlight_start = ''
                    highlight_end = ''

                if not hide_nameserver:
                    self.pprint((format).format(
                        sign=sign,
                        title='DNS Addresses:' if nameservers_displayed == 0 else '',
                        value=val,
                        start=highlight_start,
                        end=highlight_end
                        ))
                    nameservers_displayed += 1

        if self._has_diff(ifname):
            if missing_nameservers_addresses := self._get_missing_system_nameservers(ifname):
                sign = self.MINUS
                for ip in missing_nameservers_addresses:
                    self.pprint(('{sign} {title:>'+self.PAD+'} [red][highlight]{ip}[/highlight][/red]').format(
                        sign=sign,
                        title='DNS Addresses:' if nameservers_displayed == 0 else '',
                        ip=ip,
                        ))
                    nameservers_displayed += 1

    def _display_dns_search(self, ifname, data):
        lst = data.get('dns_search', [])
        searches_displayed = 0
        if lst:
            missing_netplan_search = self._get_missing_netplan_search(ifname)
            for i, val in enumerate(lst):
                sign = ''
                hide_search = False
                if self.diff and val not in missing_netplan_search:
                    format = '  [muted]{title:>'+self.PAD+'} {value}[/muted]'
                    highlight_start = ''
                    highlight_end = ''
                    if self.diff_only:
                        hide_search = True
                elif self.diff and val in missing_netplan_search:
                    sign = self.PLUS
                    format = '{sign} {title:>'+self.PAD+'} [green]{start}{value}{end}[/green]'
                    highlight_start = '[highlight]'
                    highlight_end = '[/highlight]'
                else:
                    format = '{title:>'+self.PAD+'} {value}'
                    highlight_start = ''
                    highlight_end = ''

                if not hide_search:
                    self.pprint((format).format(
                        sign=sign,
                        title='DNS Search:' if searches_displayed == 0 else '',
                        value=val,
                        start=highlight_start,
                        end=highlight_end
                        ))
                    searches_displayed += 1

        if self._has_diff(ifname):
            if missing_nameservers_search := self._get_missing_system_search(ifname):
                sign = self.MINUS
                for domain in missing_nameservers_search:
                    self.pprint(('{sign} {title:>'+self.PAD+'} [red][highlight]{domain}[/highlight][/red]').format(
                        sign=sign,
                        title='DNS Search:' if searches_displayed == 0 else '',
                        domain=domain,
                        ))
                    searches_displayed += 1

    def _display_routes(self, ifname, data):
        lst = data.get('routes', [])
        missing_netplan_routes = self._get_missing_netplan_routes(ifname)
        missing_system_routes = self._get_missing_system_routes(ifname)
        routes_displayed = 0
        if lst:
            if not self.route_lookup_table_names:
                self.route_lookup_table_names = utils.route_table_lookup()

            diff_state = NetplanDiffState(None, None)
            routes = [diff_state._system_route_to_netplan(route) for route in lst]
            if not self.verbose:
                # filter out routes that are not in the main route table
                routes = filter(lambda r: r.table == 254, routes)
            for route in routes:
                hide_route = False
                default_start = ''
                default_end = ''
                if route.to == 'default':
                    default_start = '[highlight]'
                    default_end = '[/highlight]'
                via = ''
                if route.via:
                    via = ' via ' + route.via
                src = ''
                if route.from_addr:
                    src = ' from ' + route.from_addr
                metric = ''
                if route.metric < NetplanRoute._METRIC_UNSPEC_:
                    metric = ' metric ' + str(route.metric)
                table = ''
                if self.verbose and route.table > 0:
                    table = ' table {}'.format(self.route_lookup_table_names.get(route.table, route.table))

                extra = []
                if route.protocol and route.protocol != 'kernel':
                    proto = route.protocol
                    extra.append(proto)
                if route.scope and route.scope != 'global':
                    scope = route.scope
                    extra.append(scope)
                if route.type and route.type != 'unicast':
                    type = route.type
                    extra.append(type)

                sign = ''
                if self.diff and route not in missing_netplan_routes:
                    format = '  [muted]{title:>'+self.PAD+'} {start}{to}{via}{src}{metric}{table}{end}{extra}[/muted]'
                    default_start = ''
                    default_end = ''
                    if self.diff_only:
                        hide_route = True
                elif self.diff and route in missing_netplan_routes:
                    sign = self.PLUS
                    format = '{sign} {title:>'+self.PAD+'} [green][highlight]{start}{to}{via}{src}{metric}'
                    format += '{table}{end}{extra}[/highlight][/green]'
                else:
                    format = '{title:>'+self.PAD+'} {start}{to}{via}{src}{metric}{table}{end}[muted]{extra}[/muted]'

                if not hide_route:
                    self.pprint(format.format(
                        sign=sign,
                        title='Routes:' if routes_displayed == 0 else '',
                        to=route.to,
                        via=via,
                        src=src,
                        metric=metric,
                        table=table,
                        extra=' ('+', '.join(extra)+')' if extra else '',
                        start=default_start,
                        end=default_end))
                    routes_displayed += 1

        if self.diff:
            for route in missing_system_routes:
                via = ''
                if route.via:
                    via = ' via ' + route.via
                src = ''
                if route.from_addr:
                    src = ' from ' + route.from_addr
                metric = ''
                if route.metric < NetplanRoute._METRIC_UNSPEC_:
                    metric = ' metric ' + str(route.metric)
                table = ''
                if self.verbose and route.table > 0:
                    table = ' table {}'.format(self.route_lookup_table_names.get(route.table, route.table))

                extra = []
                if route.scope and route.scope != 'global':
                    scope = route.scope
                    extra.append(scope)
                if route.type and route.type != 'unicast':
                    type = route.type
                    extra.append(type)

                sign = self.MINUS
                format = '{sign} {title:>'+self.PAD+'} {start}[red]{to}{via}{src}{metric}{table}{extra}[/red]{end}'
                self.pprint(format.format(
                    sign=sign,
                    title='Routes:' if routes_displayed == 0 else '',
                    to=route.to,
                    via=via,
                    src=src,
                    metric=metric,
                    table=table,
                    extra=' ('+', '.join(extra)+')' if extra else '',
                    start='[highlight]',
                    end='[/highlight]'))
                routes_displayed += 1

    def _display_bridge(self, ifname, data):
        val = data.get('bridge')
        if val:
            missing_netplan_bridge_link = self._get_missing_netplan_bridge_link(ifname)
            format = '{title:>'+self.PAD+'} {value}'
            sign = ''
            hide_bridge = False
            if self.diff and not missing_netplan_bridge_link:
                format = '  [muted]{title:>'+self.PAD+'} {value}[/muted]'
                if self.diff_only:
                    hide_bridge = True
            elif self.diff and missing_netplan_bridge_link:
                sign = self.PLUS
                format = '{sign} {title:>'+self.PAD+'} [highlight][green]{value}[/green][/highlight]'
                val = missing_netplan_bridge_link

            if not hide_bridge:
                self.pprint((format).format(
                    sign=sign,
                    title='Bridge:',
                    value=val,
                    ))
        if missing_system_bridge_link := self._get_missing_system_bridge_link(ifname):
            sign = self.MINUS
            format = '{sign} {title:>'+self.PAD+'} [highlight][red]{value}[/red][/highlight]'
            self.pprint((format).format(
                sign=sign,
                title='Bridge:',
                value=missing_system_bridge_link,
            ))

    def _display_bond(self, ifname, data):
        val = data.get('bond')
        if val:
            missing_netplan_bond_link = self._get_missing_netplan_bond_link(ifname)
            format = '{title:>'+self.PAD+'} {value}'
            sign = ''
            hide_bond = False
            if self.diff and not missing_netplan_bond_link:
                format = '  [muted]{title:>'+self.PAD+'} {value}[/muted]'
                if self.diff_only:
                    hide_bond = True
            elif self.diff and missing_netplan_bond_link:
                sign = self.PLUS
                format = '{sign} {title:>'+self.PAD+'} [highlight][green]{value}[/green][/highlight]'
                val = missing_netplan_bond_link

            if not hide_bond:
                self.pprint((format).format(
                    sign=sign,
                    title='Bond:',
                    value=val,
                    ))
        if missing_system_bond_link := self._get_missing_system_bond_link(ifname):
            sign = self.MINUS
            format = '{sign} {title:>'+self.PAD+'} [highlight][red]{value}[/red][/highlight]'
            self.pprint((format).format(
                sign=sign,
                title='Bond:',
                value=missing_system_bond_link,
            ))

    def _display_vrf(self, ifname, data):
        val = data.get('vrf')
        if val:
            missing_netplan_vrf_link = self._get_missing_netplan_vrf_link(ifname)
            format = '{title:>'+self.PAD+'} {value}'
            sign = ''
            hide_vrf = False
            if self.diff and not missing_netplan_vrf_link:
                format = '  [muted]{title:>'+self.PAD+'} {value}[/muted]'
                if self.diff_only:
                    hide_vrf = True
            elif self.diff and missing_netplan_vrf_link:
                sign = self.PLUS
                format = '{sign} {title:>'+self.PAD+'} [highlight][green]{value}[/green][/highlight]'
                val = missing_netplan_vrf_link

            if not hide_vrf:
                self.pprint((format).format(
                    sign=sign,
                    title='VRF:',
                    value=val,
                    ))
        if missing_system_vrf_link := self._get_missing_system_vrf_link(ifname):
            sign = self.MINUS
            format = '{sign} {title:>'+self.PAD+'} [highlight][red]{value}[/red][/highlight]'
            self.pprint((format).format(
                sign=sign,
                title='VRF:',
                value=missing_system_vrf_link,
            ))

    def _display_members(self, ifname: str, data):
        lst = data.get('interfaces', [])
        members_displayed = 0
        if lst:
            missing_netplan_interfaces = self._get_missing_netplan_members(ifname)
            for val in lst:
                sign = ''
                hide_member = False
                if self.diff and val not in missing_netplan_interfaces:
                    format = '  [muted]{title:>'+self.PAD+'} {value}[/muted]'
                    highlight_start = ''
                    highlight_end = ''
                    if self.diff_only:
                        hide_member = True
                elif self.diff and val in missing_netplan_interfaces:
                    sign = self.PLUS
                    format = '{sign} {title:>'+self.PAD+'} [green]{start}{value}{end}[/green]'
                    highlight_start = '[highlight]'
                    highlight_end = '[/highlight]'
                else:
                    format = '{title:>'+self.PAD+'} {value}'
                    highlight_start = ''
                    highlight_end = ''

                if not hide_member:
                    self.pprint((format).format(
                        sign=sign,
                        title='Interfaces:' if members_displayed == 0 else '',
                        value=val,
                        start=highlight_start,
                        end=highlight_end,
                        ))
                    members_displayed += 1

        if self._has_diff(ifname):
            if missing_members := self._get_missing_system_members(ifname):
                sign = self.MINUS
                for member in missing_members:
                    self.pprint(('{sign} {title:>'+self.PAD+'} [red][highlight]{member}[/highlight][/red]').format(
                        sign=sign,
                        title='Interfaces:' if members_displayed == 0 else '',
                        member=member,
                        ))
                    members_displayed += 1

    def _display_activation_mode(self, data):
        val = data.get('activation_mode')
        if val:
            self.pprint(('{title:>'+self.PAD+'} {value}').format(
                title='Activation Mode:',
                value=val,
                ))

    def _display_missing_interfaces(self):
        missing_interfaces = self._get_missing_system_interfaces()
        sign = self.MINUS
        for index, (interface, properties) in enumerate(missing_interfaces.items(), 1):
            # If we called netplan status for a single interface, ignore the rest
            if self.ifname and self.ifname != interface:
                continue

            self.pprint('{sign} [{col}]● {idx:>2}  {name} {type}[/{col}]'.format(
                sign=sign,
                col='red',
                idx='',
                name=interface,
                type=properties.get('type'),
                ))

            if index != len(missing_interfaces) and not self.ifname:
                # linebreak only if it's not the last interfaces or the only one
                self.pprint()

    def plain_print(self, *args, **kwargs):
        if len(args):
            lst = list(args)
            while True:
                tags = MATCH_TAGS.findall(lst[0])
                if not tags:
                    break
                for tag in tags:
                    # remove matching opening and closing tag
                    lst[0] = lst[0].replace('[{}]'.format(tag), '')\
                                   .replace('[/{}]'.format(tag), '')
            return print(*lst, **kwargs)
        return print(*args, **kwargs)

    def pretty_print(self, data: JSON, total: int, _console_width=None) -> None:
        self.pprint = self._create_pretty_print(_console_width)
        self.PLUS = '[green]+[/green]'
        self.MINUS = '[red]-[/red]'
        self.PAD = '18'
        if self.diff:
            # In diff mode we shift the text 2 columns to the right so we can display
            # + and - and maintain the alignment consistency
            self.PAD = '20'

        # Global state
        if not self.diff:
            self._display_global_state(data)

        # Per interface
        interfaces = [(key, data[key]) for key in data if key != 'netplan-global-state']
        if self.diff_only:
            # in diff-only mode we filter out interfaces that don't have any diff
            interfaces = list(filter(lambda i: self._has_diff(i[0]), interfaces))

        missing_interfaces = self._get_missing_system_interfaces()
        for index, (ifname, ifconfig) in enumerate(interfaces, 1):
            # If we called netplan status for a single interface, ignore the rest
            if self.ifname and self.ifname != ifname:
                continue

            self._display_interface_header(ifname, ifconfig)
            self._display_mac_address(ifname, ifconfig)
            self._display_ip_addresses(ifname, ifconfig)
            self._display_dns_addresses(ifname, ifconfig)
            self._display_dns_search(ifname, ifconfig)
            self._display_routes(ifname, ifconfig)
            self._display_bridge(ifname, ifconfig)
            self._display_bond(ifname, ifconfig)
            self._display_vrf(ifname, ifconfig)
            self._display_members(ifname, ifconfig)
            self._display_activation_mode(ifconfig)

            if not self.diff_only or self._has_diff(ifname):
                # we only break to a new line if we still have data to display
                if (index != len(interfaces) or len(missing_interfaces) > 0) and not self.ifname:
                    self.pprint()

        if self.diff:
            self._display_missing_interfaces()

        hidden = total - len(interfaces)
        if hidden > 0 and not self.diff:
            self.pprint('\n{} inactive interfaces hidden. Use "--all" to show all.'.format(hidden))

        if self.diff and not self.diff_only:
            self.pprint(
                '\nUse [yellow]"--diff-only"[/yellow] to omit the information that is consistent between the system and Netplan.'
            )

    def command(self):
        # --diff-only implies --diff
        if self.diff_only:
            self.diff = True

        # --diff needs data from all interfaces to work
        if self.diff:
            self.all = True

        system_state = SystemConfigState(self.ifname, self.all)

        output_format = self.format.lower()

        if self.diff:
            netplan_state = NetplanConfigState(rootdir=self.root_dir)
            diff_state = NetplanDiffState(system_state, netplan_state)

            self.state_diff = diff_state.get_diff(self.ifname)

            if output_format == 'json':
                print(json.dumps(self.state_diff, cls=DiffJSONEncoder))
                return
            elif output_format == 'yaml':
                serialized = json.dumps(self.state_diff, cls=DiffJSONEncoder)
                print(yaml.dump(json.loads(serialized)))
                return

        if output_format == 'json':  # structural JSON output
            print(json.dumps(system_state.get_data()))
        elif output_format == 'yaml':  # stuctural YAML output
            print(yaml.dump(system_state.get_data()))
        else:  # pretty print, human readable output
            self.pretty_print(system_state.get_data(), system_state.number_of_interfaces)