## -*- coding: utf-8 -*-
<%!
    import socket
    import time
    import os
    import platform
    import sys
    import gc
    import multiprocessing
    import subprocess
    import re
    import threading
    import random
    from importlib.metadata import metadata, version

    import kaithem
    from scullery import workers as sworkers
    from kaithem.api.midi import list_midi_inputs
    from kaithem.src import unitsofmeasure
    from kaithem.src import systasks
    from kaithem.src import settings_overrides
    from icemedia import sound_player as sound
    from kaithem.src import util
    from kaithem.src import astrallibwrapper as sky
    from kaithem.src import workers
    from kaithem.src.config import config

    try:
        __version__ = metadata("kaithem").get("Version", version("kaithem"))
    except Exception as e:
        __version__ = str(e)

    def sensors():
        try:
            if util.which("sensors"):
                return subprocess.check_output("sensors").decode("utf8")
            else:
                return '"sensors" command failed(lm_sensors not available)'
        except Exception:
            return "sensors call failed"

    if os.name != "nt":
        import fcntl
        import struct

        def get_interface_ip(ifname):
            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            return socket.inet_ntoa(fcntl.ioctl(s.fileno(), 0x8915, struct.pack('256s',
                                    ifname[:15].encode('utf-8') ))[20:24])

    def get_user():
        try:
            return subprocess.check_output(['whoami'])
        except Exception:
            return ""
    def get_user():
        try:
            return subprocess.check_output(['whoami'])
        except Exception:
            return ""

    def get_lan_ip():
        ip = socket.gethostbyname(socket.gethostname())
        if os.name != "nt":
            interfaces = [
                "eth0",
                "eth1",
                "eth2",
                "wlp2s0",
                "wlan0",
                "wlan1",
                "wifi0",
                "wlo0",
                "wlo1",
                "ath0",
                "ath1",
                "ppp0",
                "tun0",
                ]
            s='unknown'
            for ifname in interfaces:
                try:
                    ip = get_interface_ip(ifname)
                    s = ifname
                    if not ip.startswith("127."):
                        break
                except IOError:
                    pass
        return ip,s




    def list_ips():
        ips={}

        if os.name != "nt":
            interfaces = [
                "eth0",
                "eth1",
                "eth2",
                "wlp2s0",
                "wlan0",
                "wlan1",
                "wifi0",
                "wlo0",
                "wlo1",
                "ath0",
                "ath1",
                "ppp0",
                "tun0",
                ]
            for ifname in interfaces:
                try:
                    ips[ifname]=[get_interface_ip(ifname),None]
                except IOError:
                    pass
        try:
            import psutil
            for interface, addrs in psutil.net_if_addrs().items():
                v4 = None
                v6 = None
                for addr in addrs:
                    if addr.family == socket.AF_INET:
                        v4 = addr.address
                    elif addr.family == socket.AF_INET6:
                        v6 = addr.address
                ips[interface] = [v4, v6]
        except ImportError:
            pass

        return sorted(ips.items())


lanip =get_lan_ip()
%>

<%
try:
    import psutil
except Exception:
    psutil=None

try:
    partitions = psutil.disk_partitions(all=True)
    disks = {}

    for p in partitions:
        if p.device.startswith("/dev") or p.device=='tmpfs':
            if 'rw' in p.opts.split(","):
                id = p.device+" at " + p.mountpoint
                try:
                    disks[p.device, p.mountpoint] =  psutil.disk_usage(p.mountpoint)
                except OSError:
                    pass
except Exception:
    print(traceback.format_exc())
    disks = {}
%>
<script src="/static/js/thirdparty/qrcode.min.js"></script>

<%include file="/pageheader.html"/>
    <title>About Kaithem </title>
    <h1>About</h1>
    <section style="text-align:center">
    <img class="h-center" src="/static/img/16x9/kaithem-tavern.avif" style="width: 80%;"></img><br>
    </section>
    <section class="window paper margin">

    Available under the terms of the <a href="/license">GNU general public license</a>.</br>
    Includes external open-source libraries by third parties. <a href="https://github.com/EternityForest/KaithemAutomation/tree/master/kaithem">Get the full source code or join the conversation at GitHub.</a>
    </section>

    <div class="window paper margin">${config['about_box_banner']}</div>
    <section class="window paper margin">
    <b>Version:</b> ${__version__|h}
    </section>
    <section class="window paper margin">
        <b>LAN access QR(${lanip[1]}):</b><br>
        <div id="lanqr"></div>
        <script>
            new QRCode(document.getElementById("lanqr"), "http://${lanip[0]}:${config['http_port']}");
        </script>
    </section>
    <br>
<div class="window paper margin">
<p>


<h3>Disks</h3>
<table border=1 class="w-full"
<tr>
    <th>
        Device
    </th>
    <th>
        Mounted
    </th>
    <th>
        Size
    </th>
    <th>
        Full
    </th>
</tr>
%for i in sorted(list(disks.keys())):
<tr>
    <td>${i[0]|h}</td>
    <td>${i[1]|h}</td>
    <td>${unitsofmeasure.si_format_number(disks[i].total)|h}</td>

    %if disks[i].percent<75:

        <td>${disks[i].percent|h}%</td>
    %elif disks[i].percent<90:
        <td><span class="warning">${disks[i].percent|h}%</span></td>

    %else:
        <td><span class="danger">${disks[i].percent|h}%</span></td>
    %endif

</tr>

%endfor


</table>
<h3>Time/Weather</h3>
<table border=1 class="w-full">
    <tr>
        <td>Moon Age(Days, approx)</td>
        <td>${sky.moon_age()}</td>
    </tr>

    <tr>
        <td>Moon Illumination(approx)</td>
        <td>${sky.moon_illumination()}%</td>
    </tr>
</table>

<h3>IP Data</h3>
    <table border=1 class="w-full">
        <tr>
            <td>HTTPS(Secure) Port</td>
            <td>${config['https_port']}</td>
        </tr>
        <tr>
            <td>HTTP(Unsecure) Port</td>
            <td>${config['http_port']}</td>
        </tr>
    </table>


    <h3>Addresses</h3>
    <table border=1 class="w-full">
        <tr>
            <th>Device</th><th>IPv4</th><th>IPv6</th>
        </tr>
        %for i in list_ips():
        <tr>
            <td>${i[0]}</td>
            <td>${i[1][0]}</td>
            <td>${i[1][1]}</td>

        </tr>
        %endfor
    </table>
</p>
<p>
<h3>Current Statistics</h3>
    <table border=1 class="w-full">
        <tr>
            <td>Process Started</td>
            <td>${time.strftime(settings_overrides.get_val('core/strftime_string'),time.localtime(systasks.systemStarted))}</td>
        </tr>
        <tr>
            <td>Thread pool latency</td>
            <td>
                %try:
                ${round(sworkers.testLatency()*1000,3)}ms
                %except Exception as e:
                ${e|h}
                %endtry

            </td>
        </tr>
        <tr>
            <td>Uncollectable garbage cycles</td>
            <td>${len(gc.garbage)}</td>
        </tr>
        <tr>
            <td>
                Uptime
            </td>
            <td>
                ${unitsofmeasure.format_time_interval(time.time()-systasks.systemStarted,4)}
            </td>


        </tr>

        <%
            try:
                load = os.getloadavg()
                load = (round(load[0],2), round(load[1],2),round(load[2],2))
            except Exception:
                load = "Load average not availible on non UNIX-like systems."

            try:
                f = util.readfile("/proc/meminfo")
                total = int(re.search("MemTotal.*?([0-9]+)",f).group(1))
                free = int(re.search("MemFree.*?([0-9]+)",f).group(1))
                cache = int(re.search("Cached.*?([0-9]+)",f).group(1))

                used = round(((total - (free+cache))/1000.0),2)
                usedp = round((1-(free+cache)/float(total))*100,2)
                total = round(total/1024,2)
            except Exception as e:
                total=used=usedp = "Unavailable"

            def makecpuspan(num):
                if num> multiprocessing.cpu_count():
                    return 'style="color:red;"'
                else:
                    return ""
        %>

<tr>
    <td>System Load Average(UNIX only)</td>
    <td>
        1 min: <span ${makecpuspan(load[0])}><b>${load[0]}</b></span> 5 min: <span
            ${makecpuspan(load[1])}><b>${load[1]}</b></span>
        15 min: <span ${makecpuspan(load[2])}><b>${load[2]}</b></span>
    </td>
</tr>

<tr>
    <td>Memory Used By All Processes(UNIX only)</td>
    <td>${used} MB (${usedp}%)</td>
</tr>
<tr>
    <td>Tasks in thread pool queue</td>
    <td>${sworkers.waitingtasks()}</td>
</tr>
</table>

</p>
<p>
<h3>System Info</h3>
<table border=1 class="w-full">
    <tr>
        <td>CPU Type</td>
        <td>${platform.machine()|h}
    </tr>

    <tr>
        <td>CPU Count</td>
        <td>${multiprocessing.cpu_count()|h}
    </tr>
    <tr>
        <td>CPU</td>
        <td>${platform.processor()|h}</td>
    </tr>

    <tr>
        <td>Total Availible RAM(UNIX Only)</td>
        <td>${total|h} MB</td>
    </tr>
    <tr>
        <td>OS Type</td>
        <td>${platform.system()|h}</td>
    </tr>

    <tr>
        <td>OS Version</td>
        <td>${platform.release()|h}</td>
    </tr>
    <tr>
        <td>Python Version</td>
        <td>${platform.python_version()|h}</td>
    </tr>


    <tr>
        <td>Audio Backend</td>
        <td>${sound.backend.backendname|h}</td>
    </tr>


    <tr>
        <td>System Time Zone</td>
        <td>${time.tzname[0]|h}</td>
    </tr>
</table>
<h3>Python Path</h3>
<ul>
    %for i in sys.path:
    <li>${i|h}</li>
    %endfor
</ul>

<h3>MIDI Inputs (JACK)</h3>
<ul>
    %for i in list_midi_inputs(force_update=True):
    <li>${i|h}</li>
    %endfor
</ul>



<h3>lm_sensors output(Requires lm_sensors to be installed)</h3>
<pre>

${sensors()|h}
</pre>
<%
def module_version(m, name):
    try:
        return metadata(name)["Version"]
    except Exception:
        pass
    try:
        v = version(name)
        if v:
            return v
    except Exception:
        pass

    try:
        if hasattr(m,"__version__"):
            return m.__version__
        if hasattr(m,"version"):
            if isinstance(m.version, (str,int,float,tuple)):
                return m.version
        if hasattr(m,"VERSION"):
            return m.VERSION
        if hasattr(m,"__VERSION__"):
            return m.__VERSION__
    except Exception as e:
        return None
    return None
%>

<h2>Imported Module Versions</h2>
<details>
    <summary>Click to expand</summary>
    <table border=1 class="w-full">
        <tr>
            <th>Module</th>
            <th>Version</th>
        </tr>
        %for i in sorted(sys.modules):
        %if module_version(sys.modules[i], i):
        <tr>
            <td>${i|h}</td>
            <td>${module_version(sys.modules[i], i)|h}</td>
        </tr>
        %endif
        %endfor
    </table>
</details>
</div>
<%include file="/pagefooter.html"/>