/*
 * Copyright (C) 2013 The Android Open Source Project
 *
 * 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.
 */

package com.android.sdklib.repository.local;

import com.android.SdkConstants;
import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.sdklib.AndroidVersion;
import com.android.sdklib.IAndroidTarget;
import com.android.sdklib.ISystemImage;
import com.android.sdklib.ISystemImage.LocationType;
import com.android.sdklib.SystemImage;
import com.android.sdklib.internal.androidTarget.AddOnTarget;
import com.android.sdklib.internal.androidTarget.PlatformTarget;
import com.android.sdklib.internal.project.ProjectProperties;
import com.android.sdklib.io.FileOp;
import com.android.sdklib.io.IFileOp;
import com.android.sdklib.repository.AddonManifestIniProps;
import com.android.sdklib.repository.FullRevision;
import com.android.sdklib.repository.MajorRevision;
import com.android.sdklib.repository.descriptors.*;
import com.android.utils.Pair;
import com.google.common.base.Objects;
import com.google.common.collect.SetMultimap;
import com.google.common.collect.TreeMultimap;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

@SuppressWarnings("MethodMayBeStatic")
public class LocalAddonPkgInfo extends LocalPlatformPkgInfo {

    private static final Pattern PATTERN_LIB_DATA = Pattern.compile(
            "^([a-zA-Z0-9._-]+\\.jar);(.*)$", Pattern.CASE_INSENSITIVE);    //$NON-NLS-1$

    // usb ids are 16-bit hexadecimal values.
    private static final Pattern PATTERN_USB_IDS = Pattern.compile(
           "^0x[a-f0-9]{4}$", Pattern.CASE_INSENSITIVE);                    //$NON-NLS-1$

    @NonNull
    private final IPkgDescAddon mAddonDesc;

    public LocalAddonPkgInfo(@NonNull LocalSdk localSdk,
                             @NonNull File localDir,
                             @NonNull Properties sourceProps,
                             @NonNull AndroidVersion version,
                             @NonNull MajorRevision revision,
                             @NonNull IdDisplay vendor,
                             @NonNull IdDisplay name) {
        super(localSdk, localDir, sourceProps, version, revision, FullRevision.NOT_SPECIFIED);
        mAddonDesc = (IPkgDescAddon) PkgDesc.Builder.newAddon(version, revision, vendor, name)
                                                    .create();
    }

    @NonNull
    @Override
    public IPkgDesc getDesc() {
        return mAddonDesc;
    }

    /** The "path" of an add-on is its Target Hash. */
    @Override
    @NonNull
    public String getTargetHash() {
        return getDesc().getPath();
    }

    //-----

    /**
     * Computes a sanitized name-id based on an addon name-display.
     * This is used to provide compatibility with older add-ons that lacks the new fields.
     *
     * @param displayName A name-display field or a old-style name field.
     * @return A non-null sanitized name-id that fits in the {@code [a-zA-Z0-9_-]+} pattern.
     */
    public static String sanitizeDisplayToNameId(@NonNull String displayName) {
        String name = displayName.toLowerCase(Locale.US);
        name = name.replaceAll("[^a-z0-9_-]+", "_");      //$NON-NLS-1$ //$NON-NLS-2$
        name = name.replaceAll("_+", "_");                //$NON-NLS-1$ //$NON-NLS-2$

        // Trim leading and trailing underscores
        if (name.length() > 1) {
            name = name.replaceAll("^_+", "");            //$NON-NLS-1$ //$NON-NLS-2$
        }
        if (name.length() > 1) {
            name = name.replaceAll("_+$", "");            //$NON-NLS-1$ //$NON-NLS-2$
        }
        return name;
    }

    //-----

    /**
     * Creates the AddOnTarget. Invoked by {@link #getAndroidTarget()}.
     */
    @Override
    @Nullable
    protected IAndroidTarget createAndroidTarget() {
        LocalSdk sdk = getLocalSdk();
        IFileOp fileOp = sdk.getFileOp();

        // Parse the addon properties to ensure we can load it.
        Pair<Map<String, String>, String> infos = parseAddonProperties();

        Map<String, String> propertyMap = infos.getFirst();
        String error = infos.getSecond();

        if (error != null) {
            appendLoadError("Ignoring add-on '%1$s': %2$s", getLocalDir().getName(), error);
            return null;
        }

        // Since error==null we're not supposed to encounter any issues loading this add-on.
        try {
            assert propertyMap != null;

            String api = propertyMap.get(AddonManifestIniProps.ADDON_API);
            String name = propertyMap.get(AddonManifestIniProps.ADDON_NAME);
            String vendor = propertyMap.get(AddonManifestIniProps.ADDON_VENDOR);

            assert api != null;
            assert name != null;
            assert vendor != null;

            PlatformTarget baseTarget = null;

            // Look for a platform that has a matching api level or codename.
            LocalPkgInfo plat = sdk.getPkgInfo(PkgType.PKG_PLATFORM,
                                               getDesc().getAndroidVersion());
            if (plat instanceof LocalPlatformPkgInfo) {
                baseTarget = (PlatformTarget) ((LocalPlatformPkgInfo) plat).getAndroidTarget();
            }
            assert baseTarget != null;

            // get the optional description
            String description = propertyMap.get(AddonManifestIniProps.ADDON_DESCRIPTION);

            // get the add-on revision
            int revisionValue = 1;
            String revision = propertyMap.get(AddonManifestIniProps.ADDON_REVISION);
            if (revision == null) {
                revision = propertyMap.get(AddonManifestIniProps.ADDON_REVISION_OLD);
            }
            if (revision != null) {
                revisionValue = Integer.parseInt(revision);
            }

            // get the optional libraries
            String librariesValue = propertyMap.get(AddonManifestIniProps.ADDON_LIBRARIES);
            Map<String, String[]> libMap = null;

            if (librariesValue != null) {
                librariesValue = librariesValue.trim();
                if (!librariesValue.isEmpty()) {
                    // split in the string into the libraries name
                    String[] libraries = librariesValue.split(";");     //$NON-NLS-1$
                    if (libraries.length > 0) {
                        libMap = new HashMap<String, String[]>();
                        for (String libName : libraries) {
                            libName = libName.trim();

                            // get the library data from the properties
                            String libData = propertyMap.get(libName);

                            if (libData != null) {
                                // split the jar file from the description
                                Matcher m = PATTERN_LIB_DATA.matcher(libData);
                                if (m.matches()) {
                                    libMap.put(libName, new String[] {
                                            m.group(1), m.group(2) });
                                } else {
                                    appendLoadError(
                                            "Ignoring library '%1$s', property value has wrong format\n\t%2$s",
                                            libName, libData);
                                }
                            } else {
                                appendLoadError(
                                        "Ignoring library '%1$s', missing property value",
                                        libName, libData);
                            }
                        }
                    }
                }
            }

            // get the abi list.
            ISystemImage[] systemImages = getAddonSystemImages(fileOp);

            // check whether the add-on provides its own rendering info/library.
            boolean hasRenderingLibrary = false;
            boolean hasRenderingResources = false;

            File dataFolder = new File(getLocalDir(), SdkConstants.FD_DATA);
            if (fileOp.isDirectory(dataFolder)) {
                hasRenderingLibrary =
                    fileOp.isFile(new File(dataFolder, SdkConstants.FN_LAYOUTLIB_JAR));
                hasRenderingResources =
                    fileOp.isDirectory(new File(dataFolder, SdkConstants.FD_RES)) &&
                    fileOp.isDirectory(new File(dataFolder, SdkConstants.FD_FONTS));
            }

            AddOnTarget target = new AddOnTarget(
                    getLocalDir().getAbsolutePath(),
                    name,
                    vendor,
                    revisionValue,
                    description,
                    systemImages,
                    libMap,
                    hasRenderingLibrary,
                    hasRenderingResources,
                    baseTarget);

            // parse the legacy skins, located under SDK/addons/addon-name/skins/[skin-name]
            // and merge with the system-image skins, if any, merging them by name.
            File targetSkinFolder = target.getFile(IAndroidTarget.SKINS);

            Map<String, File> skinsMap = new TreeMap<String, File>();

            for (File f : PackageParserUtils.parseSkinFolder(targetSkinFolder, fileOp)) {
                skinsMap.put(f.getName().toLowerCase(Locale.US), f);
            }
            for (ISystemImage si : systemImages) {
                for (File f : si.getSkins()) {
                    skinsMap.put(f.getName().toLowerCase(Locale.US), f);
                }
            }

            List<File> skins = new ArrayList<File>(skinsMap.values());
            Collections.sort(skins);

            // get the default skin
            File defaultSkin = null;
            String defaultSkinName = propertyMap.get(AddonManifestIniProps.ADDON_DEFAULT_SKIN);
            if (defaultSkinName != null) {
                defaultSkin = new File(targetSkinFolder, defaultSkinName);
            } else {
                // No default skin name specified, use the first one from the addon
                // or the default from the platform.
                if (skins.size() == 1) {
                    defaultSkin = skins.get(0);
                } else {
                    defaultSkin = baseTarget.getDefaultSkin();
                }
            }

            // get the USB ID (if available)
            int usbVendorId = convertId(propertyMap.get(AddonManifestIniProps.ADDON_USB_VENDOR));
            if (usbVendorId != IAndroidTarget.NO_USB_ID) {
                target.setUsbVendorId(usbVendorId);
            }

            target.setSkins(skins.toArray(new File[skins.size()]), defaultSkin);

            return target;

        } catch (Exception e) {
            appendLoadError("Ignoring add-on '%1$s': error %2$s.",
                    getLocalDir().getName(), e.toString());
        }

        return null;

    }

    /**
     * Parses the add-on properties and decodes any error that occurs when loading an addon.
     *
     * @return A pair with the property map and an error string. Both can be null but not at the
     *  same time. If a non-null error is present then the property map must be ignored. The error
     *  should be translatable as it might show up in the SdkManager UI.
     */
    @NonNull
    private Pair<Map<String, String>, String> parseAddonProperties() {
        Map<String, String> propertyMap = null;
        String error = null;

        IFileOp fileOp = getLocalSdk().getFileOp();
        File addOnManifest = new File(getLocalDir(), SdkConstants.FN_MANIFEST_INI);

        do {
            if (!fileOp.isFile(addOnManifest)) {
                error = String.format("File not found: %1$s", SdkConstants.FN_MANIFEST_INI);
                break;
            }

            try {
                propertyMap = ProjectProperties.parsePropertyStream(
                        fileOp.newFileInputStream(addOnManifest),
                        addOnManifest.getPath(),
                        null /*log*/);
                if (propertyMap == null) {
                    error = String.format("Failed to parse properties from %1$s",
                            SdkConstants.FN_MANIFEST_INI);
                    break;
                }
            } catch (FileNotFoundException e) {
                // this can happen if the system fails to open the file because of too many
                // open files.
                error = String.format("Failed to parse properties from %1$s: %2$s",
                        SdkConstants.FN_MANIFEST_INI, e.getMessage());
                break;
            }

            // look for some specific values in the map.
            // we require name, vendor, and api
            String name = propertyMap.get(AddonManifestIniProps.ADDON_NAME);
            if (name == null) {
                error = addonManifestWarning(AddonManifestIniProps.ADDON_NAME);
                break;
            }

            String vendor = propertyMap.get(AddonManifestIniProps.ADDON_VENDOR);
            if (vendor == null) {
                error = addonManifestWarning(AddonManifestIniProps.ADDON_VENDOR);
                break;
            }

            String api = propertyMap.get(AddonManifestIniProps.ADDON_API);
            if (api == null) {
                error = addonManifestWarning(AddonManifestIniProps.ADDON_API);
                break;
            }

            // Look for a platform that has a matching api level or codename.
            IAndroidTarget baseTarget = null;
            LocalPkgInfo plat = getLocalSdk().getPkgInfo(PkgType.PKG_PLATFORM,
                                                         getDesc().getAndroidVersion());
            if (plat instanceof LocalPlatformPkgInfo) {
                baseTarget = ((LocalPlatformPkgInfo) plat).getAndroidTarget();
            }

            if (baseTarget == null) {
                error = String.format("Unable to find base platform with API level '%1$s'", api);
                break;
            }

            // get the add-on revision
            String revision = propertyMap.get(AddonManifestIniProps.ADDON_REVISION);
            if (revision == null) {
                revision = propertyMap.get(AddonManifestIniProps.ADDON_REVISION_OLD);
            }
            if (revision != null) {
                try {
                    Integer.parseInt(revision);
                } catch (NumberFormatException e) {
                    // looks like revision does not parse to a number.
                    error = String.format("%1$s is not a valid number in %2$s.",
                            AddonManifestIniProps.ADDON_REVISION, SdkConstants.FN_BUILD_PROP);
                    break;
                }
            }

        } while(false);

        return Pair.of(propertyMap, error);
    }

    /**
     * Prepares a warning about the addon being ignored due to a missing manifest value.
     * This string will show up in the SdkManager UI.
     *
     * @param valueName The missing manifest value, for display.
     */
    @NonNull
    private static String addonManifestWarning(@NonNull String valueName) {
        return String.format("'%1$s' is missing from %2$s.",
                valueName, SdkConstants.FN_MANIFEST_INI);
    }

    /**
     * Converts a string representation of an hexadecimal ID into an int.
     * @param value the string to convert.
     * @return the int value, or {@link IAndroidTarget#NO_USB_ID} if the conversion failed.
     */
    private int convertId(@Nullable String value) {
        if (value != null && !value.isEmpty()) {
            if (PATTERN_USB_IDS.matcher(value).matches()) {
                String v = value.substring(2);
                try {
                    return Integer.parseInt(v, 16);
                } catch (NumberFormatException e) {
                    // this shouldn't happen since we check the pattern above, but this is safer.
                    // the method will return 0 below.
                }
            }
        }

        return IAndroidTarget.NO_USB_ID;
    }

    /**
     * Get all the system images supported by an add-on target.
     * For an add-on,  we first look in the new sdk/system-images folders then we look
     * for sub-folders in the addon/images directory.
     * If none are found but the directory exists and is not empty, assume it's a legacy
     * arm eabi system image.
     * If any given API appears twice or more, the first occurrence wins.
     * <p/>
     * Note that it's OK for an add-on to have no system-images at all, since it can always
     * rely on the ones from its base platform.
     *
     * @param fileOp File operation wrapper.
     * @return an array of ISystemImage containing all the system images for the target.
     *              The list can be empty but not null.
    */
    @NonNull
    private ISystemImage[] getAddonSystemImages(IFileOp fileOp) {
        Set<ISystemImage> found = new TreeSet<ISystemImage>();
        SetMultimap<IdDisplay, String> tagToAbiFound = TreeMultimap.create();


        // Look in the system images folders:
        // - SDK/system-image/platform/addon-id-tag/abi
        // - SDK/system-image/addon-id-tag/abi (many abi possible)
        // Optional: look for skins under
        // - SDK/system-image/platform/addon-id-tag/abi/skins/skin-name
        // - SDK/system-image/addon-id-tag/abi/skins/skin-name
        // If we find multiple occurrences of the same platform/abi, the first one read wins.

        LocalPkgInfo[] sysImgInfos = getLocalSdk().getPkgsInfos(PkgType.PKG_ADDON_SYS_IMAGE);
        for (LocalPkgInfo pkg : sysImgInfos) {
            IPkgDesc d = pkg.getDesc();
            if (pkg instanceof LocalAddonSysImgPkgInfo &&
                    d.hasVendor() &&
                    mAddonDesc.getVendor().equals(d.getVendor()) &&
                    mAddonDesc.getName().equals(d.getTag()) &&
                    Objects.equal(mAddonDesc.getAndroidVersion(), pkg.getDesc().getAndroidVersion())) {
                final IdDisplay tag = mAddonDesc.getName();
                final String abi = d.getPath();
                if (abi != null && !tagToAbiFound.containsEntry(tag, abi)) {
                    found.add(((LocalAddonSysImgPkgInfo)pkg).getSystemImage());
                    tagToAbiFound.put(tag, abi);
                }
            }
        }

        // Look for sub-directories:
        // - SDK/addons/addon-name/images/abi (multiple abi possible)
        // - SDK/addons/addon-name/armeabi (legacy support)
        boolean useLegacy = true;
        boolean hasImgFiles = false;
        final IdDisplay defaultTag = SystemImage.DEFAULT_TAG;

        File imagesDir = new File(getLocalDir(), SdkConstants.OS_IMAGES_FOLDER);
        File[] files = fileOp.listFiles(imagesDir);
        for (File file : files) {
            if (fileOp.isDirectory(file)) {
                useLegacy = false;
                String abi = file.getName();
                if (!tagToAbiFound.containsEntry(defaultTag, abi)) {
                    found.add(new SystemImage(
                            file,
                            LocationType.IN_IMAGES_SUBFOLDER,
                            SystemImage.DEFAULT_TAG,
                            mAddonDesc.getVendor(),
                            abi,
                            FileOp.EMPTY_FILE_ARRAY));
                    tagToAbiFound.put(defaultTag, abi);
                }
            } else if (!hasImgFiles && fileOp.isFile(file)) {
                if (file.getName().endsWith(".img")) {                  //$NON-NLS-1$
                    // The legacy images folder is only valid if it contains some .img files
                    hasImgFiles = true;
                }
            }
        }

        if (useLegacy &&
                hasImgFiles &&
                fileOp.isDirectory(imagesDir) &&
                !tagToAbiFound.containsEntry(defaultTag, SdkConstants.ABI_ARMEABI)) {
            // We found no sub-folder system images but it looks like the top directory
            // has some img files in it. It must be a legacy ARM EABI system image folder.
            found.add(new SystemImage(
                    imagesDir,
                    LocationType.IN_LEGACY_FOLDER,
                    SystemImage.DEFAULT_TAG,
                    SdkConstants.ABI_ARMEABI,
                    FileOp.EMPTY_FILE_ARRAY));
        }

        return found.toArray(new ISystemImage[found.size()]);
    }
}