#!/usr/bin/env python
#
# Copyright 2014-present Facebook, Inc.
#
# Licensed 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.
#

"""This script will compile an Xcode 5 asset catalog (*.xcassets) in a fashion
that is compatible with legacy bundle placement.  For instance, asset catalogs
flatten all assets into a single namespace and all assets will be placed in
the main application bundle's resource path's root.  However, when using a
bundle, the bundle's directory would be placed in the same place, thus
allowing for a hierarchy.

For example, when building an application called Sample.app that references a
Resource.bundle in its Copy Resources build phase, the files in the bundle
would be placed at Sample.app/Resource.bundle/<files>.  If the bundle's image
assets are moved to an asset catalog, the files are placed in at
Sample.app/<files>.  This creates namespacing issues for code that references
these resources.

This script manipulates the asset catalog compiler (actool) to place resources
in the expected place."""

import optparse
import errno
import logging
import os
import os.path
import re
import subprocess
import sys

import StringIO

logger = logging.getLogger('compile_asset_catalog')


def get_xcode_path():
    cmd = ['xcode-select', '--print-path']
    return subprocess.check_output(cmd).strip()


def get_actool_env_path(platform):
    platform = 'iPhoneSimulator'
    if platform != 'iphonesimulator':
        platform = 'iPhoneOS'
    xcode_path = get_xcode_path()
    return ':'.join([
        os.path.join(
            xcode_path,
            'Platforms',
            platform + '.platform',
            'Developer/usr/bin/actool'),
        os.path.join(xcode_path, 'usr/bin'),
        '/usr/bin',
        '/bin',
        '/usr/sbin',
        '/sbin'])


def version_components_from_string(v):
    return v.split('.')


def major_version_from_version_string(v):
    return int(version_components_from_string(v)[0])


def minor_version_from_version_string(v):
    components = version_components_from_string(v)
    if len(components) < 2:
        raise ValueError(v + ': does not have a minor version')
    return int(components[1])


def catalog_name_from_path(path):
    return os.path.splitext(os.path.basename(path))[0]


def actool_cmds(target, platform, devices, output, catalog_paths,
                split_into_bundles):
    """Returns an array of tuples.  Each tuple is (command, output_directory).
       command is an array of command line parameters, while directory is a
       directory that is expected to exist."""

    # When splitting into bundles, Assets.car cannot be used, so force the
    # deployment target to a version that does not support it.
    if split_into_bundles:
        if (platform == 'macosx' and
                minor_version_from_version_string(target) >= 9):
            target = '10.8'
        elif major_version_from_version_string(target) >= 7:
            target = '6.0'

    base_cmd = [
        'actool',
        '--output-format',
        'human-readable-text',
        '--notices',
        '--warnings',
        '--platform',
        platform,
        '--minimum-deployment-target',
        target]

    for d in devices:
        base_cmd.extend(['--target-device', d])

    base_cmd.extend(['--compress-pngs', '--compile'])

    if split_into_bundles:
        bundle_directories = [
            catalog_name_from_path(path) + '.bundle' for path in catalog_paths]
        output_directories = [
            os.path.join(output, bundle) for bundle in bundle_directories]

        pairs = zip(output_directories, catalog_paths)
        cmds = []
        for (output_directory, catalog_path) in pairs:
            cmd = list(base_cmd)
            cmd.extend([output_directory, catalog_path])
            cmds.append(cmd)

        return zip(cmds, output_directories)
    else:
        base_cmd.append(output)
        base_cmd.extend(catalog_paths)
        return [(base_cmd, output)]


def mkdir_p(path):
    try:
        os.makedirs(path)
    except OSError as e:
        if e.errno == errno.EEXIST and os.path.isdir(path):
            pass
        else:
            raise


# We don't know all the different types of potential warnings actool outputs.
# We assume that they have some potential preamble, then "warning:" and then
# the message. In the case that the preamble is a path, we truncate the path
# to a suffix that indicates the asset name to make it easier to debug in
# Xcode.
ACTOOL_WARNING_REGEX = re.compile(
    '(?P<asset_path>.*:)?\s*warning:\s*(?P<message>.*)')


def transform_actool_output_line(line):
    line = line.rstrip()

    # Xcode seems to ignore actool's warnings when they are piped through
    # stdout as normal.  We want to treat these as errors that must be
    # resolved.  This filter formats the warnings nicely to make it easy to
    # resolve them.
    #
    # Sample:
    #   /path/to/images.xcassets:./some.imageset: warning: ...
    # should be:
    #  error: images.xcassets:./some.imageset: warning: ...
    matches = ACTOOL_WARNING_REGEX.match(line)
    if matches:
        groups = matches.groupdict()
        if (groups['asset_path']):
            groups['asset_path'] = os.path.basename(groups['asset_path'])
        line = 'error: ' + groups['asset_path'] + ': ' + groups['message']
    return line


def transform_actool_output(stdout, verbose):
    has_errors = False
    is_error = False

    # Using `for line in proc.stdout` causes OS X to barf with errno=35.  Not
    # sure why, but it appears to be a rate limiting issue.  Creating the loop
    # manually appears to resolve the issue.
    line = stdout.readline()
    while line:
        line = transform_actool_output_line(line)
        if line.startswith('error:'):
            is_error = True
            has_errors = True
        if is_error or verbose:
            print line
        line = stdout.readline()
    return not has_errors


def compile_asset_catalogs(target, platform, devices, output, catalogs,
                           split_into_bundles, verbose):
    cmd_pairs = actool_cmds(
        target,
        platform,
        devices,
        output,
        catalogs,
        split_into_bundles)
    actool_env_path = get_actool_env_path(platform)

    env = os.environ.copy()
    env['PATH'] = actool_env_path

    errors_encountered = False

    for (cmd, output_directory) in cmd_pairs:
        mkdir_p(output_directory)

        logger.info('PATH=' + actool_env_path + ' ' + ' '.join(cmd))

        # The explicit PATH is provided because Xcode runs actool with an
        # explicit PATH when it runs as part of the automatic "Copy Bundle
        # Resources" phase.  This ensures that the tool is run in the same
        # environment as expected.
        #
        # Note that check_output raises an exception if the exit code
        # indicates an error, which is the desired behavior here.
        actool_output = subprocess.check_output(cmd, env=env)
        actool_stdout = StringIO.StringIO(actool_output)
        success = transform_actool_output(actool_stdout, verbose)

        if not success:
            errors_encountered = True

    return not errors_encountered


if __name__ == "__main__":
    parser = optparse.OptionParser()
    parser.add_option('-t', '--target',
                      help='Target operating system version for deployment')
    parser.add_option('-p', '--platform',
                      help='Target platform.  Choices are iphonesimulator, '
                      'iphoneos, and macosx.')
    parser.add_option('-d', '--device', action='append', type=str,
                      help='Choices are iphone and ipad. May be specified '
                      'multiple times. When platform is macosx, this '
                      'option cannot be specified. Otherwise, this option '
                      'must be specified.')
    parser.add_option('-b', '--bundles', action='store_true',
                      help='Use the legacy output format, which copies '
                      'asset catalogs to their sibling bundles. Without '
                      'this option, all assets are copied to the root (or '
                      'compiled into Assets.car)')
    parser.add_option('-o', '--output',
                      help='Output directory for the specified asset '
                      'catalog(s).')
    parser.add_option('-v', '--verbose', action='store_true',
                      help='Print verbose output')
    opts, args = parser.parse_args()

    logging.basicConfig(
        level=(logging.DEBUG if opts.verbose else logging.INFO))
    logger.info('Compiling asset catalogs...')

    catalogs = map(os.path.abspath, args)
    opts.output = os.path.abspath(opts.output)

    # Validation:
    #
    # - deployment target is a version string
    # - platform is one of the appropriate choices
    # - when platform is macosx, devices are not specified.  Otherwise,
    #   devices must be specified
    # - devices are valid values
    # - asset catalogs paths end in .xcassets
    for component in opts.target.split('.'):
        try:
            int(component)
        except:
            raise ValueError(opts.target + ': target must be a version string')

    if (opts.platform != 'iphonesimulator' and opts.platform != 'iphoneos'
            and opts.platform != 'macosx'):
        raise ValueError(opts.platform + ': platform must be either '
                         'iphoneos, iphonesimulator, or macosx')

    if opts.platform == 'macosx' and opts.device is not None:
        raise ValueError(
            'devices must not be specified when platform is macosx')
    elif opts.platform != 'macosx' and (opts.device or len(opts.device) == 0):
        raise ValueError('devices must be specified when platform is iphoneos '
                         'or iphonesimulator')

    if opts.device is not None:
        for device in opts.device:
            if device != 'iphone' and device != 'ipad':
                raise ValueError(
                    device + ': device(s) must be either iphone or ipad')

    for path in catalogs:
        if os.path.splitext(os.path.basename(path))[1] != '.xcassets':
            raise ValueError(
                path + ': catalog paths must have an xcassets extension')

    # When the target platform is macosx, the device supplied to actool is
    # 'mac'
    if opts.platform == 'macosx':
        opts.device = ['mac']

    exit_code = 0
    if not compile_asset_catalogs(opts.target, opts.platform, opts.device,
                                  opts.output, catalogs,
                                  opts.bundles, opts.verbose):
        exit_code = 1

    logger.info('Done')
    sys.exit(exit_code)