/**
 * Copyright (c) 2010, 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 android.content;

import android.graphics.Bitmap;
import android.net.Uri;
import android.os.Parcel;
import android.os.Parcelable;
import android.text.TextUtils;

import java.util.ArrayList;

/**
 * Representation of a clipped data on the clipboard.
 *
 * <p>ClippedData is a complex type containing one or Item instances,
 * each of which can hold one or more representations of an item of data.
 * For display to the user, it also has a label and iconic representation.</p>
 *
 * <p>The types than an individial item can currently contain are:</p>
 *
 * <ul>
 * <li> Text: a basic string of text.  This is actually a CharSequence,
 * so it can be formatted text supported by corresponding Android built-in
 * style spans.  (Custom application spans are not supported and will be
 * stripped when transporting through the clipboard.)
 * <li> Intent: an arbitrary Intent object.  A typical use is the shortcut
 * to create when pasting a clipped item on to the home screen.
 * <li> Uri: a URI reference.  Currently this should only be a content: URI.
 * This representation allows an application to share complex or large clips,
 * by providing a URI to a content provider holding the data.
 * </ul>
 */
public class ClippedData implements Parcelable {
    CharSequence mLabel;
    Bitmap mIcon;

    final ArrayList<Item> mItems = new ArrayList<Item>();

    public static class Item {
        CharSequence mText;
        Intent mIntent;
        Uri mUri;

        public Item(CharSequence text) {
            mText = text;
        }

        public Item(Intent intent) {
            mIntent = intent;
        }

        public Item(Uri uri) {
            mUri = uri;
        }

        public Item(CharSequence text, Intent intent, Uri uri) {
            mText = text;
            mIntent = intent;
            mUri = uri;
        }

        public CharSequence getText() {
            return mText;
        }

        public Intent getIntent() {
            return mIntent;
        }

        public Uri getUri() {
            return mUri;
        }
    }

    /**
     * Create a new clip.
     *
     * @param label Label to show to the user describing this clip.
     * @param icon Bitmap providing the user with an iconing representation of
     * the clip.
     * @param item The contents of the first item in the clip.
     */
    public ClippedData(CharSequence label, Bitmap icon, Item item) {
        if (item == null) {
            throw new NullPointerException("item is null");
        }
        mLabel = label;
        mIcon = icon;
        mItems.add(item);
    }

    public void addItem(Item item) {
        if (item == null) {
            throw new NullPointerException("item is null");
        }
        mItems.add(item);
    }

    public CharSequence getLabel() {
        return mLabel;
    }

    public Bitmap getIcon() {
        return mIcon;
    }

    public int getItemCount() {
        return mItems.size();
    }

    public Item getItem(int index) {
        return mItems.get(index);
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        TextUtils.writeToParcel(mLabel, dest, flags);
        if (mIcon != null) {
            dest.writeInt(1);
            mIcon.writeToParcel(dest, flags);
        } else {
            dest.writeInt(0);
        }
        final int N = mItems.size();
        dest.writeInt(N);
        for (int i=0; i<N; i++) {
            Item item = mItems.get(i);
            TextUtils.writeToParcel(item.mText, dest, flags);
            if (item.mIntent != null) {
                dest.writeInt(1);
                item.mIntent.writeToParcel(dest, flags);
            } else {
                dest.writeInt(0);
            }
            if (item.mUri != null) {
                dest.writeInt(1);
                item.mUri.writeToParcel(dest, flags);
            } else {
                dest.writeInt(0);
            }
        }
    }

    ClippedData(Parcel in) {
        mLabel = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(in);
        if (in.readInt() != 0) {
            mIcon = Bitmap.CREATOR.createFromParcel(in);
        }
        final int N = in.readInt();
        for (int i=0; i<N; i++) {
            CharSequence text = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(in);
            Intent intent = in.readInt() != 0 ? Intent.CREATOR.createFromParcel(in) : null;
            Uri uri = in.readInt() != 0 ? Uri.CREATOR.createFromParcel(in) : null;
            mItems.add(new Item(text, intent, uri));
        }
    }

    public static final Parcelable.Creator<ClippedData> CREATOR =
        new Parcelable.Creator<ClippedData>() {

            public ClippedData createFromParcel(Parcel source) {
                return new ClippedData(source);
            }

            public ClippedData[] newArray(int size) {
                return new ClippedData[size];
            }
        };
}