#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import asyncio
import yaml
import fnmatch
import os
import sys
import asfpy.pubsub
import irc.client
import irc.client_aio
import base64

MAX_LOG_LEN = 200
INTERNAL_TIMEOUT = 30  # Internal 30 second timeout for monitoring the pubsub loop.


def files_touched(files):
    """Finds the root path of files touched by this commit, as well as returns a short summary of what was touched"""
    if isinstance(files, dict):  # svn returns a dict, we only care about the filenames, so convert to list
        files = list(files.keys())
    if not files:  # No files touched, likely a branch or tag was created/deleted
        return "", "No files touched"
    if len(files) == 1:  # Just one file, return that
        return files[0], files[0]
    paths = files[0].split("/")
    commit_files = 0
    commit_dirs = set()
    for file in files:
        commit_files += 1
        commit_dirs.add(os.path.dirname(file))
        while not file.startswith("/".join(paths)):
            paths.pop()
            if len(paths) == 0:
                break
    root_path = "/".join(paths)
    commit_dirs = len(commit_dirs) == 1 and "1 directory" or f"{len(commit_dirs)} directories"
    commit_files = commit_files == 1 and "1 file" or f"{commit_files} files"
    return root_path, f"{root_path} ({commit_files} in {commit_dirs})"


def format_message(payload):
    """Formats a commit payload into an IRC message"""
    commit = payload.get("commit")
    if not commit:  # Probably a still-alive ping, ignore
        return "", ""
    commit_type = commit.get("repository")
    commit_root, commit_files = files_touched(commit.get("files") or commit.get("changed", {}))
    if commit_type == "git":
        commit_subject = commit.get("subject")
        author = commit.get("email", "unknown@apache.org")
        commit_repo = commit.get("project")
        tag = commit.get("ref", "main").replace("refs/heads/", "").replace("refs/tags/", "")  # Strip refs/*/ away
        sha = commit.get("hash", "0000000")
        url = f"https://gitbox.apache.org/repos/asf?p={commit_repo}.git;h={sha}"
        return (
            f"git:{commit_repo}",
            f"\x033 {author}\x03 \x02{tag} * {sha}\x0f ({commit_files}) {url}: {commit_subject}",
        )
    else:  # if not git, then svn
        author = commit.get("committer", "unknown") + "@apache.org"
        commit_subject = commit.get("log", "No log provided")
        commit_subject = " ".join(commit_subject.split("\n"))
        if len(commit_subject) > MAX_LOG_LEN:
            commit_subject = commit_subject[: MAX_LOG_LEN - 3] + "..."
        revision = commit.get("id", "1")
        url = f"https://svn.apache.org/r{revision}"
        return f"svn:{commit_root}", f"\x033 {author}\x03 \x02r{revision}\x0f ({commit_files}) {url}: {commit_subject}"


class SASLMixin(irc.client_aio.AioSimpleIRCClient):
    """Mixin for the IRC client, adding simple SASL capabilities"""

    def __init__(self):
        super(irc.client_aio.AioSimpleIRCClient, self).__init__()
        self.reactor._on_connect = self._on_connect
        for event in ["cap", "authenticate", "903", "908"]:
            self.connection.add_global_handler(event, getattr(self, f"_on_{event}"))

    def _on_connect(self, sock, event):
        """Send CAP REQ :sasl on connect."""
        self.connection.cap("REQ", "sasl")

    def _on_cap(self, conn, event):
        """Handle CAP responses."""
        if event.arguments and event.arguments[0] == "ACK":
            conn.send_raw("AUTHENTICATE PLAIN")
        else:
            print("Unexpected CAP response: %s", event)
            conn.disconnect()

    def _on_authenticate(self, conn, event):
        """Handle AUTHENTICATE responses."""
        if event.target == "+":
            creds = "{username}\0{username}\0{password}".format(
                username=self.config["client"]["nick"], password=self.password
            )
            conn.send_raw("AUTHENTICATE {}".format(base64.b64encode(creds.encode("utf8")).decode("utf8")))
        else:
            print("Unexpcted AUTHENTICATE response: %s", event)
            conn.disconnect()

    def _on_903(self, conn, event):
        """903: RPL_SASLSUCCESS"""
        self.connection.cap("END")

    def _on_908(self, conn, event):
        """908: RPL_SASLMECHS (PLAIN SASL not supported)"""
        print("SASL PLAIN not supported: %s", event)
        self.die()


class CommitbotClient(SASLMixin):
    def __init__(self, config: dict):
        super(CommitbotClient, self).__init__()
        self.config = config
        self.future = None
        self.password = None

    def run(self):
        self.password = open(self.config["client"]["password"]).read().strip()
        self.connect(
            self.config["server"]["host"],
            self.config["server"]["port"],
            self.config["client"]["nick"],
            ircname=self.config["client"]["realname"],
        )
        try:
            self.start()
        finally:
            self.connection.disconnect()
            self.reactor.loop.close()

    def on_welcome(self, connection, event):
        for channel in self.config["channels"]:
            self.connection.join(channel)
            print(f"Joined {channel}")

        self.future = asyncio.ensure_future(self.pubsub_poll(), loop=connection.reactor.loop)

    def on_disconnect(self, connection, event):
        if self.future:
            self.future.cancel()
        sys.exit(0)

        
    async def pubsub_poll(self):
        while True:
            async for payload in asfpy.pubsub.listen(self.config["pubsub_host"]):
                root, msg = format_message(payload)
                if msg:
                    to_channels = []
                    for channel, data in self.config["channels"].items():
                        for tag in data.get("tags", []):
                            if fnmatch.fnmatch(root, tag):
                                to_channels.append(channel)
                                break
                    if to_channels:
                        self.connection.privmsg_many(to_channels, msg)
                        await asyncio.sleep(1)  # Don't flood too quickly
        self.connection.quit("Bye!")


def main():
    print("Starting CommitBot")
    config = yaml.safe_load(open("config.yaml"))
    bot = CommitbotClient(config)
    bot.run()


if __name__ == "__main__":
    main()