# -*- coding: utf-8 -*-
# Copyright (c) 2024 Salvador E. Tropea
# Copyright (c) 2024 Instituto Nacional de Tecnología Industrial
# License: AGPL-3.0
# Project: KiBot (formerly KiPlot)
import requests
import os
from .error import KiPlotConfigurationError
from .gs import GS
from .kiplot import load_sch, load_board
from .out_base import VariantOptions
from .macros import macros, document, output_class  # noqa: F401
from . import log

logger = log.get_logger()
VALID_SOURCE = {'schematic', 'pcb', 'project'}
URL_SCRIPT = 'https://kicanvas.org/kicanvas/kicanvas.js'
SCRIPT_NAME = 'kicanvas.js'
JS_TEST = """
function ready()
{
 try
   {
    var xmlhttp = new XMLHttpRequest();
    xmlhttp.open('GET', 'fname', false);
    xmlhttp.send();
   }
 catch (error)
   {
    if (window.location.protocol === 'file:')
      {
       document.getElementById('no_file_access').style.display = 'block';
      }
    throw(error);
   }
}

window.addEventListener('DOMContentLoaded', ready);
"""


class KiCanvasOptions(VariantOptions):
    def __init__(self):
        with document:
            self.source = 'schematic'
            """ *[string|list(string)] [schematic,pcb,project] Source to display """
            self.local_script = True
            """ *Download the script and use a copy """
            self.title = ''
            """ Text used to replace the sheet title. %VALUE expansions are allowed.
                If it starts with `+` the text is concatenated """
            self.url_script = URL_SCRIPT
            """ URL for the KiCanvas script """
            self.controls = 'full'
            """ [full,basic,none] Which controls are displayed """
            self.download = True
            """ Show the download button """
            self.overlay = True
            """ Show the overlay asking to click """
        super().__init__()
        self._expand_ext = 'html'
        self._expand_id = 'kicanvas'

    def config(self, parent):
        super().config(parent)
        self.source = self.force_list(self.source, lower_case=True)
        for s in self.source:
            if s not in VALID_SOURCE:
                raise KiPlotConfigurationError(f'Invalid source `{s}` must be any of: {", ".join(VALID_SOURCE)}')

    def get_html_name(self, out_dir):
        return os.path.join(out_dir, self.expand_filename_sch(self._parent.output))

    def _get_targets(self, out_dir, only_index=False):
        files = [self.get_html_name(out_dir)]
        if only_index:
            return files
        if self.local_script:
            files.append(os.path.join(out_dir, SCRIPT_NAME))
        for s in self.source:
            if s == 'pcb' and GS.pcb_fname:
                files.append(os.path.join(out_dir, GS.pcb_fname))
            elif s == 'schematic' and GS.sch_file:
                files.extend(GS.sch.file_names_variant(out_dir))
            elif s == 'project' and (GS.sch_file or GS.pcb_file):
                files.extend(GS.copy_project_names(GS.sch_file or GS.pcb_file, ref_dir=out_dir))
        return files

    def get_targets(self, out_dir):
        return self._get_targets(out_dir)

    def get_navigate_targets(self, out_dir):
        """ Targets for the navigate results, just the index """
        return self._get_targets(out_dir, True)

    def save_pcb(self, out_dir):
        out_pcb = os.path.join(out_dir, GS.pcb_fname)
        if self._pcb_saved:
            return out_pcb
        self._pcb_saved = True
        self.set_title(self.title)
        self.filter_pcb_components(do_3D=True)
        logger.debug('Saving PCB to '+out_pcb)
        GS.board.Save(out_pcb)
        self.unfilter_pcb_components(do_3D=True)
        self.restore_title()
        return out_pcb

    def save_sch(self, out_dir):
        if self._sch_saved:
            return
        self._sch_saved = True
        self.set_title(self.title, sch=True)
        logger.debug('Saving Schematic to '+out_dir)
        GS.sch.save_variant(out_dir)
        self.restore_title(sch=True)

    def run(self, out_dir):
        # We declare _any_related=True because we don't know if the PCB/SCH are needed until the output is configured.
        # Now that we know it we can load the PCB and/or SCH.
        for s in self.source:
            if s == 'pcb':
                load_board()
            elif s == 'schematic':
                load_sch()
            else:
                load_sch()
                load_board()
                GS.check_pro()
        # Now that we loaded the needed stuff we can do the parent run
        super().run(out_dir)
        # Download KiCanvas
        if self.local_script:
            logger.debug(f'Downloading the script from `{self.url_script}`')
            try:
                r = requests.get(self.url_script, allow_redirects=True)
            except Exception as e:
                raise KiPlotConfigurationError(f'Failed to download the KiCanvas script from `{self.url_script}`: '+str(e))
            dest = os.path.join(out_dir, SCRIPT_NAME)
            logger.debug(f'Saving the script to `{dest}`')
            GS.write_to_file(r.content, dest)
            script_src = SCRIPT_NAME
        else:
            script_src = self.url_script
        # Generate all pages
        self._sch_saved = self._pcb_saved = False
        for s in self.source:
            # Save the PCB/SCH/Project
            if s == 'pcb':
                self.save_pcb(out_dir)
            elif s == 'schematic':
                self.save_sch(out_dir)
            else:
                self.save_sch(out_dir)
                GS.copy_project(self.save_pcb(out_dir))
        # Create the HTML file
        full_name = self.get_html_name(out_dir)
        logger.debug(f'Creating KiCanvas HTML: {full_name}')
        controlslist = []
        if not self.download:
            controlslist.append('nodownload')
        if not self.overlay:
            controlslist.append('nooverlay')
        controlslist = f' controlslist="{",".join(controlslist)}"' if controlslist else ''
        with GS.create_file(full_name) as f:
            f.write('<!DOCTYPE HTML>\n')
            f.write('<html lang="en">\n')
            f.write('  <body>\n')
            f.write(f'    <script type="module" src="{script_src}"></script>\n')
            # Message to inform we can't read the local files
            f.write('    <div id="no_file_access" style="display: none; ">\n')
            f.write("      <span>The browser can't read local files. Enable it to continue."
                    " I.e. use <i>--allow-file-access-from-files</i> on Chrome</span>\n")
            f.write('    </div>\n')
            # End of message
            f.write(f'    <kicanvas-embed controls="{self.controls}"{controlslist}>\n')
            fname = None
            for s in self.source:
                if s == 'pcb':
                    f.write(f'      <kicanvas-source src="{GS.pcb_fname}"></kicanvas-source>\n')
                    fname = GS.pcb_fname
                elif s == 'schematic':
                    GS.sch_dir
                    for s in sorted(GS.sch.all_sheets, key=lambda x: x.sheet_path_h):
                        fname = os.path.relpath(s.fname, GS.sch_dir)
                        f.write(f'      <kicanvas-source src="{fname}"></kicanvas-source>\n')
                else:
                    f.write(f'      <kicanvas-source src="{GS.pro_fname}"></kicanvas-source>\n')
                    fname = GS.pro_fname
            f.write('    </kicanvas-embed>\n')
            # Add test to check if we can read the files
            f.write('    <script>\n')
            f.write(JS_TEST.replace('fname', fname))
            f.write('    </script>\n')
            # End of test
            f.write('  </body>\n')
            f.write('</html>\n')


@output_class
class KiCanvas(BaseOutput):  # noqa: F821
    """ KiCanvas
        Generates an interactive web page to browse the schematic and/or PCB.
    """
    def __init__(self):
        super().__init__()
        self._category = ['PCB/docs', 'Schematic/docs']
        self._any_related = True
        with document:
            self.output = GS.def_global_output
            """ *Filename for the output (%i=kicanvas, %x=html) """
            self.options = KiCanvasOptions
            """ *[dict] Options for the KiCanvas output """

    def config(self, parent):
        super().config(parent)
        if self.get_user_defined('category'):
            # The user specified a category, don't change it
            return
        # Adjust the category according to the selected output/s
        cat = set()
        for s in self.options.source:
            if s == 'pcb':
                cat.add('PCB/docs')
            elif s == 'schematic':
                cat.add('Schematic/docs')
            else:
                cat.add('PCB/docs')
                cat.add('Schematic/docs')
        self.category = list(cat)

    @staticmethod
    def get_conf_examples(name, layers):
        outs = BaseOutput.simple_conf_examples(name, 'Web page to browse the schematic and/or PCB', 'Browse')  # noqa: F821
        sources = []
        if GS.sch_file:
            sources.append('schematic')
        if GS.pcb_file:
            sources.append('pcb')
        outs[0]['options'] = {'source': sources}
        return outs

    def get_navigate_targets(self, out_dir):
        return (self.options.get_navigate_targets(out_dir), [os.path.join(GS.get_resource_path('kicanvas'), 'kicanvas.svg')])