/*
 * Copyright (C) 2012 The Android Open Source Project
 *
 * Licensed under the Eclipse Public License, Version 1.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.eclipse.org/org/documents/epl-v10.php
 *
 * 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.ide.eclipse.adt.internal.editors.layout.configuration;

import static com.android.SdkConstants.ANDROID_STYLE_RESOURCE_PREFIX;
import static com.android.SdkConstants.ATTR_NAME;
import static com.android.SdkConstants.ATTR_THEME;
import static com.android.SdkConstants.PREFIX_RESOURCE_REF;
import static com.android.SdkConstants.STYLE_RESOURCE_PREFIX;

import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.ide.common.resources.ResourceRepository;
import com.android.ide.common.resources.configuration.DeviceConfigHelper;
import com.android.ide.common.resources.configuration.FolderConfiguration;
import com.android.ide.common.resources.configuration.LocaleQualifier;
import com.android.ide.common.resources.configuration.ScreenSizeQualifier;
import com.android.ide.eclipse.adt.AdtPlugin;
import com.android.ide.eclipse.adt.internal.editors.manifest.ManifestInfo;
import com.android.ide.eclipse.adt.internal.editors.manifest.ManifestInfo.ActivityAttributes;
import com.android.ide.eclipse.adt.internal.sdk.AndroidTargetData;
import com.android.ide.eclipse.adt.internal.sdk.Sdk;
import com.android.resources.NightMode;
import com.android.resources.ResourceFolderType;
import com.android.resources.ScreenSize;
import com.android.resources.UiMode;
import com.android.sdklib.IAndroidTarget;
import com.android.sdklib.devices.Device;
import com.android.sdklib.devices.State;
import com.google.common.base.Splitter;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.QualifiedName;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

import java.util.Collection;
import java.util.List;

/** A description of a configuration, used for persistence */
public class ConfigurationDescription {
    private static final String TAG_PREVIEWS = "previews";    //$NON-NLS-1$
    private static final String TAG_PREVIEW = "preview";      //$NON-NLS-1$
    private static final String ATTR_TARGET = "target";       //$NON-NLS-1$
    private static final String ATTR_CONFIG = "config";       //$NON-NLS-1$
    private static final String ATTR_LOCALE = "locale";       //$NON-NLS-1$
    private static final String ATTR_ACTIVITY = "activity";   //$NON-NLS-1$
    private static final String ATTR_DEVICE = "device";       //$NON-NLS-1$
    private static final String ATTR_STATE = "devicestate";   //$NON-NLS-1$
    private static final String ATTR_UIMODE = "ui";           //$NON-NLS-1$
    private static final String ATTR_NIGHTMODE = "night";     //$NON-NLS-1$
    private final static String SEP_LOCALE = "-";             //$NON-NLS-1$

    /**
     * Settings name for file-specific configuration preferences, such as which theme or
     * device to render the current layout with
     */
    public final static QualifiedName NAME_CONFIG_STATE =
        new QualifiedName(AdtPlugin.PLUGIN_ID, "state");//$NON-NLS-1$

    /** The project corresponding to this configuration's description */
    public final IProject project;

    /** The display name */
    public String displayName;

    /** The theme */
    public String theme;

    /** The target */
    public IAndroidTarget target;

    /** The display name */
    public FolderConfiguration folder;

    /** The locale */
    public Locale locale = Locale.ANY;

    /** The device */
    public Device device;

    /** The device state */
    public State state;

    /** The activity */
    public String activity;

    /** UI mode */
    @NonNull
    public UiMode uiMode = UiMode.NORMAL;

    /** Night mode */
    @NonNull
    public NightMode nightMode = NightMode.NOTNIGHT;

    private ConfigurationDescription(@Nullable IProject project) {
        this.project = project;
    }

    /**
     * Returns the persistent configuration description from the given file
     *
     * @param file the file to look up a description from
     * @return the description or null if never written
     */
    @Nullable
    public static String getDescription(@NonNull IFile file) {
        return AdtPlugin.getFileProperty(file, NAME_CONFIG_STATE);
    }

    /**
     * Sets the persistent configuration description data for the given file
     *
     * @param file the file to associate the description with
     * @param description the description
     */
    public static void setDescription(@NonNull IFile file, @NonNull String description) {
        AdtPlugin.setFileProperty(file, NAME_CONFIG_STATE, description);
    }

    /**
     * Creates a description from a given configuration
     *
     * @param project the project for this configuration's description
     * @param configuration the configuration to describe
     * @return a new configuration
     */
    public static ConfigurationDescription fromConfiguration(
            @Nullable IProject project,
            @NonNull Configuration configuration) {
        ConfigurationDescription description = new ConfigurationDescription(project);
        description.displayName = configuration.getDisplayName();
        description.theme = configuration.getTheme();
        description.target = configuration.getTarget();
        description.folder = new FolderConfiguration();
        description.folder.set(configuration.getFullConfig());
        description.locale = configuration.getLocale();
        description.device = configuration.getDevice();
        description.state = configuration.getDeviceState();
        description.activity = configuration.getActivity();
        return description;
    }

    /**
     * Initializes a string previously created with
     * {@link #toXml(Document)}
     *
     * @param project the project for this configuration's description
     * @param element the element to read back from
     * @param deviceList list of available devices
     * @return true if the configuration was initialized
     */
    @Nullable
    public static ConfigurationDescription fromXml(
            @Nullable IProject project,
            @NonNull Element element,
            @NonNull Collection<Device> deviceList) {
        ConfigurationDescription description = new ConfigurationDescription(project);

        if (!TAG_PREVIEW.equals(element.getTagName())) {
            return null;
        }

        String displayName = element.getAttribute(ATTR_NAME);
        if (!displayName.isEmpty()) {
            description.displayName = displayName;
        }

        String config = element.getAttribute(ATTR_CONFIG);
        Iterable<String> segments = Splitter.on('-').split(config);
        description.folder = FolderConfiguration.getConfig(segments);

        String theme = element.getAttribute(ATTR_THEME);
        if (!theme.isEmpty()) {
            description.theme = theme;
        }

        String targetId = element.getAttribute(ATTR_TARGET);
        if (!targetId.isEmpty()) {
            IAndroidTarget target = Configuration.stringToTarget(targetId);
            description.target = target;
        }

        String localeString = element.getAttribute(ATTR_LOCALE);
        if (!localeString.isEmpty()) {
            // Load locale. Note that this can get overwritten by the
            // project-wide settings read below.
            String locales[] = localeString.split(SEP_LOCALE);
            if (locales[0].length() > 0 && !LocaleQualifier.FAKE_VALUE.equals(locales[0])) {
                String language = locales[0];
                if (locales.length >= 2 && locales[1].length() > 0 && !LocaleQualifier.FAKE_VALUE.equals(locales[1])) {
                    description.locale = Locale.create(LocaleQualifier.getQualifier(language + "-r" + locales[1]));
                } else {
                    description.locale = Locale.create(new LocaleQualifier(language));
                }
            } else {
                description.locale = Locale.ANY;
            }


        }

        String activity = element.getAttribute(ATTR_ACTIVITY);
        if (activity.isEmpty()) {
            activity = null;
        }

        String deviceString = element.getAttribute(ATTR_DEVICE);
        if (!deviceString.isEmpty()) {
            for (Device d : deviceList) {
                if (d.getName().equals(deviceString)) {
                    description.device = d;
                    String stateName = element.getAttribute(ATTR_STATE);
                    if (stateName.isEmpty() || stateName.equals("null")) {
                        description.state = Configuration.getState(d, stateName);
                    } else if (d.getAllStates().size() > 0) {
                        description.state = d.getAllStates().get(0);
                    }
                    break;
                }
            }
        }

        String uiModeString = element.getAttribute(ATTR_UIMODE);
        if (!uiModeString.isEmpty()) {
            description.uiMode = UiMode.getEnum(uiModeString);
            if (description.uiMode == null) {
                description.uiMode = UiMode.NORMAL;
            }
        }

        String nightModeString = element.getAttribute(ATTR_NIGHTMODE);
        if (!nightModeString.isEmpty()) {
            description.nightMode = NightMode.getEnum(nightModeString);
            if (description.nightMode == null) {
                description.nightMode = NightMode.NOTNIGHT;
            }
        }


        // Should I really be storing the FULL configuration? Might be trouble if
        // you bring a different device

        return description;
    }

    /**
     * Write this description into the given document as a new element.
     *
     * @param document the document to add the description to
     * @return the newly inserted element
     */
    @NonNull
    public Element toXml(Document document) {
        Element element = document.createElement(TAG_PREVIEW);

        element.setAttribute(ATTR_NAME, displayName);
        FolderConfiguration fullConfig = folder;
        String folderName = fullConfig.getFolderName(ResourceFolderType.LAYOUT);
        element.setAttribute(ATTR_CONFIG, folderName);
        if (theme != null) {
            element.setAttribute(ATTR_THEME, theme);
        }
        if (target != null) {
            element.setAttribute(ATTR_TARGET, Configuration.targetToString(target));
        }

        if (locale != null && (locale.hasLanguage() || locale.hasRegion())) {
            String value;
            if (locale.hasRegion()) {
                value = locale.qualifier.getLanguage() + SEP_LOCALE + locale.qualifier.getRegion();
            } else {
                value = locale.qualifier.getLanguage();
            }
            element.setAttribute(ATTR_LOCALE, value);
        }

        if (device != null) {
            element.setAttribute(ATTR_DEVICE, device.getName());
            if (state != null) {
                element.setAttribute(ATTR_STATE, state.getName());
            }
        }

        if (activity != null) {
            element.setAttribute(ATTR_ACTIVITY, activity);
        }

        if (uiMode != null && uiMode != UiMode.NORMAL) {
            element.setAttribute(ATTR_UIMODE, uiMode.getResourceValue());
        }

        if (nightMode != null && nightMode != NightMode.NOTNIGHT) {
            element.setAttribute(ATTR_NIGHTMODE, nightMode.getResourceValue());
        }

        Element parent = document.getDocumentElement();
        if (parent == null) {
            parent = document.createElement(TAG_PREVIEWS);
            document.appendChild(parent);
        }
        parent.appendChild(element);

        return element;
    }

    /** Returns the preferred theme, or null */
    @Nullable
    String computePreferredTheme() {
        if (project == null) {
            return "Theme";
        }
        ManifestInfo manifest = ManifestInfo.get(project);

        // Look up the screen size for the current state
        ScreenSize screenSize = null;
        if (device != null) {
            List<State> states = device.getAllStates();
            for (State s : states) {
                FolderConfiguration folderConfig = DeviceConfigHelper.getFolderConfig(s);
                if (folderConfig != null) {
                    ScreenSizeQualifier qualifier = folderConfig.getScreenSizeQualifier();
                    screenSize = qualifier.getValue();
                    break;
                }
            }
        }

        // Look up the default/fallback theme to use for this project (which
        // depends on the screen size when no particular theme is specified
        // in the manifest)
        String defaultTheme = manifest.getDefaultTheme(target, screenSize);

        String preferred = defaultTheme;
        if (theme == null) {
            // If we are rendering a layout in included context, pick the theme
            // from the outer layout instead

            if (activity != null) {
                ActivityAttributes attributes = manifest.getActivityAttributes(activity);
                if (attributes != null) {
                    preferred = attributes.getTheme();
                }
            }
            if (preferred == null) {
                preferred = defaultTheme;
            }
            theme = preferred;
        }

        return preferred;
    }

    private void checkThemePrefix() {
        if (theme != null && !theme.startsWith(PREFIX_RESOURCE_REF)) {
            if (theme.isEmpty()) {
                computePreferredTheme();
                return;
            }

            if (target != null) {
                Sdk sdk = Sdk.getCurrent();
                if (sdk != null) {
                    AndroidTargetData data = sdk.getTargetData(target);

                    if (data != null) {
                        ResourceRepository resources = data.getFrameworkResources();
                        if (resources != null
                            && resources.hasResourceItem(ANDROID_STYLE_RESOURCE_PREFIX + theme)) {
                            theme = ANDROID_STYLE_RESOURCE_PREFIX + theme;
                            return;
                        }
                    }
                }
            }

            theme = STYLE_RESOURCE_PREFIX + theme;
        }
    }
}