# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.

from __future__ import unicode_literals

import getpass
import os
import sys
import time

from collections import namedtuple

# keep in sync with psutil os support, see psutil/__init__.py
if sys.platform.startswith("freebsd") or sys.platform.startswith("darwin") or sys.platform.startswith("win32") or sys.platform.startswith("linux"):
    try:
        import psutil
    except ImportError:
        psutil = None
else:
    psutil = None

from ..compilation.warnings import (
    WarningsCollector,
    WarningsDatabase,
)


BuildOutputResult = namedtuple('BuildOutputResult',
    ('warning', 'state_changed', 'for_display'))


class BuildMonitor(object):
    """Monitors the output of the build."""

    def __init__(self, topobjdir, warnings_path):
        """Create a new monitor.

        warnings_path is a path of a warnings database to use.
        """
        self._warnings_path = warnings_path

        self.tiers = []
        self.subtiers = []
        self.current_tier = None
        self.current_subtier = None
        self.current_tier_dirs = []
        self.current_tier_static_dirs = []
        self.current_subtier_dirs = []
        self.current_tier_dir = None
        self.current_tier_dir_index = 0

        self.warnings_database = WarningsDatabase()
        if os.path.exists(warnings_path):
            try:
                self.warnings_database.load_from_file(warnings_path)
            except ValueError:
                os.remove(warnings_path)

        self._warnings_collector = WarningsCollector(
            database=self.warnings_database, objdir=topobjdir)

    def start(self):
        """Record the start of the build."""
        self.start_time = time.time()
        self._finder_start_cpu = self._get_finder_cpu_usage()

    def on_line(self, line):
        """Consume a line of output from the build system.

        This will parse the line for state and determine whether more action is
        needed.

        Returns a BuildOutputResult instance.

        In this named tuple, warning will be an object describing a new parsed
        warning. Otherwise it will be None.

        state_changed indicates whether the build system changed state with
        this line. If the build system changed state, the caller may want to
        query this instance for the current state in order to update UI, etc.

        for_display is a boolean indicating whether the line is relevant to the
        user. This is typically used to filter whether the line should be
        presented to the user.
        """
        if line.startswith('BUILDSTATUS'):
            args = line.split()[1:]

            action = args.pop(0)
            update_needed = True

            if action == 'TIERS':
                self.tiers = args
                update_needed = False
            elif action == 'SUBTIERS':
                self.subtiers = args
                update_needed = False
            elif action == 'STATICDIRS':
                self.current_tier_static_dirs = args
                update_needed = False
            elif action == 'DIRS':
                self.current_tier_dirs = args
                update_needed = False
            elif action == 'TIER_START':
                assert len(args) == 1
                self.current_tier = args[0]
                self.current_subtier = None
                self.current_tier_dirs = []
                self.current_tier_dir = None
            elif action == 'TIER_FINISH':
                assert len(args) == 1
                assert args[0] == self.current_tier
            elif action == 'SUBTIER_START':
                assert len(args) == 2
                tier, subtier = args
                assert tier == self.current_tier
                self.current_subtier = subtier
                if subtier == 'static':
                    self.current_subtier_dirs = self.current_tier_static_dirs
                else:
                    self.current_subtier_dirs = self.current_tier_dirs
                self.current_tier_dir_index = 0
            elif action == 'SUBTIER_FINISH':
                assert len(args) == 2
                tier, subtier = args
                assert tier == self.current_tier
                assert subtier == self.current_subtier
            elif action == 'TIERDIR_START':
                assert len(args) == 1
                self.current_tier_dir = args[0]
                self.current_tier_dir_index += 1
            elif action == 'TIERDIR_FINISH':
                assert len(args) == 1
                assert self.current_tier_dir == args[0]
            else:
                raise Exception('Unknown build status: %s' % action)

            return BuildOutputResult(None, update_needed, False)

        warning = None

        try:
            warning = self._warnings_collector.process_line(line)
        except:
            pass

        return BuildOutputResult(warning, False, True)

    def finish(self):
        """Record the end of the build."""
        self.end_time = time.time()
        self._finder_end_cpu = self._get_finder_cpu_usage()
        self.elapsed = self.end_time - self.start_time

        self.warnings_database.prune()
        self.warnings_database.save_to_file(self._warnings_path)

    def _get_finder_cpu_usage(self):
        """Obtain the CPU usage of the Finder app on OS X.

        This is used to detect high CPU usage.
        """
        if not sys.platform.startswith('darwin'):
            return None

        if not psutil:
            return None

        for proc in psutil.process_iter():
            if proc.name != 'Finder':
                continue

            if proc.username != getpass.getuser():
                continue

            # Try to isolate system finder as opposed to other "Finder"
            # processes.
            if not proc.exe.endswith('CoreServices/Finder.app/Contents/MacOS/Finder'):
                continue

            return proc.get_cpu_times()

        return None

    def have_high_finder_usage(self):
        """Determine whether there was high Finder CPU usage during the build.

        Returns True if there was high Finder CPU usage, False if there wasn't,
        or None if there is nothing to report.
        """
        if not self._finder_start_cpu:
            return None, None

        # We only measure if the measured range is sufficiently long.
        if self.elapsed < 15:
            return None, None

        if not self._finder_end_cpu:
            return None, None

        start = self._finder_start_cpu
        end = self._finder_end_cpu

        start_total = start.user + start.system
        end_total = end.user + end.system

        cpu_seconds = end_total - start_total

        # If Finder used more than 25% of 1 core during the build, report an
        # error.
        finder_percent = cpu_seconds / self.elapsed * 100

        return finder_percent > 25, finder_percent