"""
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, either version 3 of the License,
or (at your option) any later version.


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 <https://www.gnu.org/licenses/>.

Copyright © 2019 Cloud Linux Software Inc.

This software is also available under ImunifyAV commercial license,
see <https://www.imunify360.com/legal/eula>
"""
import asyncio
import itertools
import logging
import time
from typing import Dict, Iterator, List, Optional, Tuple

from imav.malwarelib.scan import ScanFailedError
from defence360agent.contracts.config import Core as Config
from defence360agent.contracts.messages import MessageType

from .ai_bolit.scanner import AiBolit
from .scan_result import DirectAiBolit, PrepareFileList, ScanResult, event_hook

logger = logging.getLogger(__name__)


class MalwareScanner:
    def __init__(self, tmpdir=None, sink=None, hooks=False):
        self._tmpdir = tmpdir or Config.TMPDIR
        self._sink = sink
        self._hooks = hooks

        self.aibolit = None
        self._task = None
        self._loop = asyncio.get_event_loop()
        self._tmpdir = tmpdir
        self._current_task = None
        self._future_result = None
        self._is_running = asyncio.Lock()

    def start(self, path, *args, **kwargs):
        self._future_result = asyncio.Future()
        self._task = self._loop.create_task(self._start(path, *args, **kwargs))
        return self._task

    def wait(self):
        if self._future_result is None:
            raise asyncio.exceptions.InvalidStateError("Need to start action")

        self._loop.run_until_complete(self._future_result)
        return self._future_result.result()

    async def async_wait(self):
        if self._future_result is None:
            raise asyncio.exceptions.InvalidStateError("Need to start action")

        await self._future_result
        return self._future_result.result()

    def stop(self):
        if self.status():
            self._task.cancel()

    def status(self):
        return self._is_running.locked()

    def _try_set_result(self, result):
        if self._future_result.done():
            return
        self._future_result.set_result(result)

    def _try_set_exception(self, exception):
        if self._future_result.done():
            return
        self._future_result.set_exception(exception)

    async def _start(self, path, *args, **kwargs):
        async with self._is_running:
            try:
                execute_scan = self._execute_scan
                if self._hooks:
                    execute_scan = event_hook(self._sink)(execute_scan)
                result = await execute_scan(path, *args, **kwargs)
            except asyncio.CancelledError:
                self._try_set_result(None)
            except Exception as e:
                self._try_set_exception(e)
            else:
                self._try_set_result(result)

    async def _send_scan_failed_message(self, e):
        if self._sink:
            try:
                msg = MessageType.ScanFailed()

                msg["exception"] = e.__class__.__name__
                if isinstance(e, ScanFailedError):
                    msg["return_code"] = e.return_code
                    msg["command"] = e.command
                    msg["out"] = e.out
                    msg["err"] = e.err
                    msg["message"] = e.message
                    msg["path"] = e.path
                    msg["scan_id"] = e.scan_id
                else:
                    msg["message"] = str(e)

                await self._sink.process_message(msg)
            except asyncio.CancelledError:
                raise
            except Exception:
                logger.exception("Exception while sending ScanFailed message")

    async def _execute_scan(self, path, *args, **kwargs):
        logger.info("Scan started")

        files_provider = (
            DirectAiBolit if isinstance(path, str) else PrepareFileList
        )

        prepare_file_list = files_provider(self._tmpdir)
        kwargs["begin_time"] = time.time()

        execute_scan = prepare_file_list(self._run_aibolit)
        result = await execute_scan(path, *args, **kwargs)

        assert isinstance(result, ScanResult)
        end_time = None if result.is_detached() else time.time()
        result.set_start_stop(end_time=end_time)

        if result.is_detached():
            return result.to_dict_initial()
        else:
            if self.aibolit and self.aibolit.cmd:
                result.args = self.aibolit.cmd
            return result.to_dict()

    async def _run_aibolit(
        self, file: Optional[str], **scan_options
    ) -> Tuple[List[Iterator[Dict]], Optional[str]]:
        """
        :param file: file with list of files, that should be scanned
        :param scan_options: some options for the scan
        :return: parse report iterator and error
        """
        iterators = []
        error = None
        self.aibolit = AiBolit()
        scan = self.aibolit.scan

        try:
            self._current_task = scan
            try:
                iterator = await scan(file, **scan_options)
            except asyncio.CancelledError:
                # all over here, task is cancelled, passing exc up
                raise
            except ScanFailedError as e:
                await self._send_scan_failed_message(e)
                logger.exception("Scan failed with ScanFailed exception")
                iterator = []
                error = e.message

            except Exception as e:
                await self._send_scan_failed_message(e)
                logger.exception("Scan failed with ordinary exception")
                iterator = []
                error = repr(e)

            # copy iterator
            result, _ = itertools.tee(iterator)
            iterators.append(result)
        finally:
            self._current_task = None

        return iterators, error
