#!/usr/bin/env python3.8
# Copyright 2021 The Fuchsia Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import argparse
import json
import sys
import os


def main():
    """Writes SDK atom-format metadata based on SDK element metadata.

    This script should only be run via the sdk_element_adapter GN template.

    Returns:
      None if successful, otherwise a string describing the error.
    """
    parser = argparse.ArgumentParser()
    parser.add_argument(
        '--depfile-path', help='A path to the depfile.', required=True)
    parser.add_argument(
        '--gn-label',
        help='GN label, with toolchain, of the SDK element adapter.',
        required=True)
    parser.add_argument(
        '--gn-meta-path',
        help='Path to a file containing GN collected metadata. '
        'See sdk_element_adapter() for the format.',
        required=True)
    parser.add_argument(
        '--atom-meta-path',
        help='Path to write .meta.json file to.',
        required=True)
    parser.add_argument(
        '--atom-manifest-path',
        help='Path to write .sdk file to.',
        required=True)
    parser.add_argument(
        '--root-build-dir',
        help='Root build dir used for rebasing the packaging manifest.',
        required=True)
    parser.add_argument(
        '--sdk-category', help='SDK atom category.', required=True)
    args = parser.parse_args()

    with open(args.gn_meta_path, 'r') as gn_meta_file:
        gn_meta = json.load(gn_meta_file)[0]  # expected to contain one item

    # Read the SDK element metadata file.
    element_meta_path = os.path.relpath(
        gn_meta['meta']['source'], args.root_build_dir)
    with open(element_meta_path, 'r') as element_meta_file:
        element_meta = json.load(element_meta_file)

    adapter = Adapter(
        element_meta, gn_meta, args.gn_label, args.root_build_dir,
        args.sdk_category, args.atom_meta_path).adapt()

    with open(args.atom_meta_path, 'w') as atom_meta_file:
        json.dump(adapter['meta'], atom_meta_file, indent=2, sort_keys=True)

    with open(args.atom_manifest_path, 'w') as atom_manifest_file:
        json.dump(
            adapter['manifest'], atom_manifest_file, indent=2, sort_keys=True)

    with open(args.depfile_path, 'w') as depfile_file:
        depfile_file.write(
            '{}: {}\n'.format(args.atom_meta_path, element_meta_path))


class Adapter(object):
    """The adapter generates SDK atom files from SDK element GN metadata."""

    def __init__(
            self, element_meta, gn_meta, gn_label, base_out_dir, category,
            atom_meta_path):
        """Initializes the adapter instances.

        Args:
            element_meta: The SDK element metadata parsed from JSON. The
            format is determined by the element type but in general it is
            always a versioned envelope. See
            //sdk/schema/common-00000000.json.
            gn_metadata: The sdk_element() GN collected metadata. See
            sdk_element GN template.
            gn_label: A GN label of the sdk_element_adapter() target.
            base_out_dir: The root of the GN output directory used to compute
            relative paths.
            category: The SDK category. See sdk_atom() template.
            atom_meta_path: A path of the atom metadata file that is created
            by this adapter. The path is relative to base_out_dir.
        """
        self.element_meta = element_meta
        self.gn_meta = gn_meta
        self.gn_label = gn_label
        self.base_out_dir = base_out_dir
        self.category = category
        self.atom_meta_path = atom_meta_path

        # Derived properties
        self.name = element_meta['data']['name']
        self.element_type = element_meta['data']['element_type'] if 'element_type' in element_meta['data'] else element_meta['data']['type']

    def adapt(self):
        """Generates an adapter dict containing manifest and metadata."""
        return getattr(self, '_adapt_{}'.format(self.element_type))()

    def _adapt_version_history(self):
        # Version history is pure metadata. There are no other files.
        # Moreover, the metadata format is shared between sdk_element and sdk_atom.
        # We can copy it as is.

        # Version history is written into the SDK root dir hence no base dir.
        dest_base = ''

        # Version history is pure metadata so return the metadata directly.
        return self._adapter(
            self.element_meta,
            self._manifest(
                'sdk://version_history',
                self._atom_manifest_files(dest_base, 'version_history.json')))

    def _adapt_host_tool(self):
        dest_root = 'tools'
        # Host tools end up in tools/${hos_arch} directories in the SDK
        dest_base = os.path.join(
            dest_root, self.element_meta['data']['host_arch'])

        id = 'sdk://{}/{}'.format(dest_base, self.name)

        meta = {
            'files': self._atom_meta_files(dest_base),
            'name': self.name,
            'root': dest_root,
            'type': self.element_type
        }

        return self._adapter(
            meta,
            self._manifest(
                id,
                self._atom_manifest_files(
                    dest_base, '{}-meta.json'.format(self.name))))

    def _atom_meta_files(self, dest_base):
        """Returns a list of files as it appears in the atom metadata.

        The list excludes the metadata file itself since it would result in a
        circular ref.

        Args:
          dest_base: The base output dir inside the SDK archive.

        Returns: A list of file paths inside the SDK archive.
        """
        return [
            os.path.join(dest_base, file['dest'])
            for file in self.gn_meta['files']
        ]

    def _atom_manifest_files(self, dest_base, dest_meta_path):
        """Return a list of mapping between build output and SDK archive.

        The list is as it appears in the atom manifest. It includes the atom
        metadata file.

        Args:
          dest_base: The base output dir inside the SDK archive.
          dest_meta_path: The name of the atom metadata path in the SDK archive
            relative to dest_base.

        Returns:
          A list of dicts where each dict contains 'source' and 'destination'
          with source being a path inside `build_out_dir` and destination a
          path inside the SDK archive.
        """
        # Include the metadata mapping as the *last* entry.
        # Please note the atom_meta_path is relative to base_out_dir already.
        # Thus it should not be rebased.
        return [
            {
                'destination': os.path.join(dest_base, file['dest']),
                'source': os.path.relpath(file['source'], self.base_out_dir),
            } for file in self.gn_meta['files']
        ] + [
            {
                'source': self.atom_meta_path,
                'destination': os.path.join(dest_base, dest_meta_path)
            }
        ]

    def _adapter(self, meta, manifest):
        return {
            'meta': meta,
            'manifest': manifest,
        }

    def _manifest(self, id, files):
        """Generates the SDK atom manifest.

        The manifest is written into the output dir with the .sdk extension.
        The manifest is used to package atoms into a single SDK archive.

        Args:
          id: The SDK atom ID.
          files: A list of dict where every dict contains 'source' and
            'destination' where the source is a path relative to the build
            output dir and destination is the location in the SDK relative
            to the SDK root. This list includes the SDK metadata.

        Returns: A dict corresponding to the JSON manifest.

        """
        return {
            'atoms':
                [
                    {
                        'category': self.category,
                        'deps': [],
                        'files': files,
                        'gn-label': self.gn_label,
                        'id': id,
                        'meta': files[-1]['destination'],  # We appended meta
                        'plasa': [],
                        'type': self.element_type,
                    }
                ],
            'ids': [id]
        }


if __name__ == '__main__':
    sys.exit(main())