/*
 * Copyright (C) 2012 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.motorola.studio.android.videos.model;

import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import com.motorola.studio.android.common.log.StudioLogger;
import com.motorola.studio.android.common.utilities.HttpUtils;
import com.motorola.studio.android.videos.Activator;
import com.motorola.studio.android.videos.implementation.youtube.YoutubeVideoServiceProvider;
import com.motorola.studio.android.videos.model.extension.VideoServiceProvider;

/**
 * Manage the actions related to videos, including loading them and 
 * providing any related information to other classes.
 */
public class VideoManager
{

    /*
     * Sort options 
     */
    public static final int SORT_MOST_RECENT = 0;

    public static final int SORT_MOST_VIEWED = 1;

    public static final int SORT_TOP_RATED = 2;

    /*
     * Video channels and source definitions (XML)
     */
    public static final String VIDEOS_DEFINITIONS = "resources/motodev_videos.xml";

    public static final String TAG_USER = "user";

    public static final String TAG_USER_ATT_NAME = "name";

    public static final String TAG_CHANNEL = "channel";

    public static final String TAG_CHANNEL_ATT_NAME = "name";

    public static final String TAG_CHANNEL_ATT_DISPLAY_NAME = "display_name";

    // "fixed" or "variable"
    public static final String TAG_CHANNEL_ATT_ORDER = "order";

    public static final String TAG_CHANNEL_ATT_ORDER_FIXED = "fixed";

    // "true" or "false"
    public static final String TAG_CHANNEL_ATT_DEFAULT = "default";

    /*
     * Singleton 
     */
    private static VideoManager instance;

    /*
     * The selected video service provider
     */
    private VideoServiceProvider videoServiceProvider = null;

    /*
     * Credentials information to be passed to the video service provider
     */
    private String userName = null;

    /*
     * The video channel objects (the videos themselves are attributes of these objects)
     */
    private String defaultVideoChannel = null;

    // Map "channel name" -> object that represent the video channel
    private final Map<String, VideoChannel> channelsMap = new HashMap<String, VideoChannel>();

    private final List<VideoChannel> channelsList = new ArrayList<VideoChannel>();

    /**
     * Singleton
     * 
     * @return a unique VideoManager instance   
     * @throws Exception 
     */
    public static synchronized VideoManager getInstance() throws Exception
    {
        if (instance == null)
        {
            instance = new VideoManager();
        }
        return instance;
    }

    /**
     * Load all channels and videos
     */
    public void load() throws Exception
    {
        channelsMap.clear();
        channelsList.clear();

        File file =
                new File(FileLocator.toFileURL(
                        Activator.getDefault().getBundle().getEntry(VIDEOS_DEFINITIONS)).getPath());

        DocumentBuilder documentBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
        Document doc = documentBuilder.parse(file);

        /*
         * Get service username
         */
        NodeList user = doc.getElementsByTagName(TAG_USER);
        Node userNameNode = user.item(0).getAttributes().getNamedItem(TAG_USER_ATT_NAME);
        userName = userNameNode.getNodeValue();

        /*
         * Initialize video service provider
         */
        videoServiceProvider = new YoutubeVideoServiceProvider(userName);

        /*
         * Get all channels
         */
        NodeList channels = doc.getElementsByTagName(TAG_CHANNEL);

        for (int i = 0; i < channels.getLength(); i++)
        {

            Node channel = channels.item(i);
            String displayName =
                    channel.getAttributes().getNamedItem(TAG_CHANNEL_ATT_DISPLAY_NAME)
                            .getTextContent();
            String name =
                    channel.getAttributes().getNamedItem(TAG_CHANNEL_ATT_NAME).getTextContent();
            boolean order = false;
            boolean defaultChannel = false;
            if (channel.getAttributes().getNamedItem(TAG_CHANNEL_ATT_ORDER) != null)
            {
                order =
                        channel.getAttributes().getNamedItem(TAG_CHANNEL_ATT_ORDER)
                                .getTextContent().equals(TAG_CHANNEL_ATT_ORDER_FIXED) ? true
                                : false;
            }
            if (channel.getAttributes().getNamedItem(TAG_CHANNEL_ATT_DEFAULT) != null)
            {
                defaultChannel =
                        channel.getAttributes().getNamedItem(TAG_CHANNEL_ATT_DEFAULT)
                                .getTextContent().equals(new Boolean(true).toString()) ? true
                                : false;
            }

            /*
             * Create and populate the channels
             */
            VideoChannel videoChannel = new VideoChannel(name);
            videoChannel.setDisplayName(displayName);
            videoChannel.setOrdered(order);
            videoChannel.setDefaultChannel(defaultChannel);
            if (defaultChannel)
            {
                defaultVideoChannel = name;
            }
            List<Video> videos = videoServiceProvider.loadVideos(videoChannel);
            if (videos != null)
            {
                videoChannel.setVideos(videos);
            }
            else
            {
                videoChannel.setActive(false);
            }
            channelsMap.put(name, videoChannel);
            channelsList.add(videoChannel);

        }

    }

    /**
     * Sort all videos from all channels
     * 
     * @param criteria
     */
    public void sort(final int criteria)
    {
        for (VideoChannel channel : channelsList)
        {
            if (!channel.isOrdered())
            {
                List<Video> videos = channel.getVideos();
                Collections.sort(videos, new Comparator<Video>()
                {

                    public int compare(Video arg0, Video arg1)
                    {
                        int result = 0;

                        switch (criteria)
                        {
                            case VideoManager.SORT_MOST_RECENT:
                                result = arg0.getDate().compareTo(arg1.getDate());
                                break;
                            case VideoManager.SORT_MOST_VIEWED:
                                result = arg0.getViews() >= arg1.getViews() ? 1 : -1;
                                break;
                            case VideoManager.SORT_TOP_RATED:
                                result = arg0.getRating() >= arg1.getRating() ? 1 : -1;
                                break;

                        }
                        return result;
                    }
                });
            }
        }
    }

    /**
     * Get videos from a channel
     * 
     * @param channel channel to retrieve the videos
     */
    public List<Video> getVideos(VideoChannel channel)
    {
        List<Video> videos = null;
        if (channelsMap.get(channel.getName()) != null)
        {
            videos = channelsMap.get(channel.getName()).getVideos();
        }
        return videos;
    }

    /**
     * Get all channels
     * 
     * @return all channels
     */
    public List<VideoChannel> getChannels()
    {
        return channelsList;
    }

    /**
     * Get only the active channels
     * 
     * @return the active channels, which were found by the video service provider
     */
    public List<VideoChannel> getActiveChannels()
    {
        List<VideoChannel> activeVideoChannels = new ArrayList<VideoChannel>();
        for (VideoChannel channel : channelsList)
        {
            if (channel.isActive())
            {
                activeVideoChannels.add(channel);
            }
        }
        return activeVideoChannels;
    }

    /**
     * Get the default channel, to be selected in the UI by default
     * 
     * @return the default channel
     */
    public VideoChannel getDefaultChannel()
    {
        return channelsMap.get(defaultVideoChannel);
    }

    /**
     * Rate a video
     * 
     * @param video video to be rated
     * @param rate video rate
     */
    public void rate(Video video, int rate) throws Exception
    {
        // delegate to the video service provider
        videoServiceProvider.rate(video, rate);
    }

    /**
     * Search all videos from all channels
     * 
     * @param keyword search keyword
     * @return only the videos that match the keyword
     */
    public List<Video> search(String keyword)
    {

        List<Video> selectedVideos = new ArrayList<Video>();

        // split the keyword into tokens
        String[] tokens = keyword.split("\\s");
        int numberOfTokens = tokens.length;

        /*
         * For each channel, search the videos and try to find all
         * tokens on each video
         */
        int visibleVideosInChannel;
        for (VideoChannel channel : channelsList)
        {
            visibleVideosInChannel = 0;
            for (Video video : channel.getVideos())
            {

                int tokensFound = 0;

                if (numberOfTokens > 0)
                {
                    StringBuffer sb = new StringBuffer();
                    sb.append(video.getTitle());
                    sb.append(" ");
                    sb.append(video.getDescription());
                    sb.append(" ");
                    sb.append(video.getKeywords());

                    for (int i = 0; i < tokens.length; i++)
                    {
                        String token = tokens[i];
                        if (sb.toString().toUpperCase().contains(token.toUpperCase()))
                        {
                            tokensFound++;
                        }
                    }
                }

                // if all tokens were found, mark the video as visible ...
                if (tokensFound == numberOfTokens)
                {
                    video.setVisible(true);
                    visibleVideosInChannel++;
                    selectedVideos.add(video);
                }
                // ... otherwise, mark the video as not visible
                else
                {
                    video.setVisible(false);
                }
            }
            channel.setVisibleVideos(visibleVideosInChannel);
        }

        return selectedVideos;

    }

    /**
     * Get the video thumbnail from the internet, given its URL
     * 
     * @param url video URL
     * @return the file representing the downloaded thumbnail
     */
    public File getThumbnail(URL url)
    {

        File cacheIconFile = null;
        HttpUtils httpUtils = new HttpUtils();
        InputStream inStream = null;
        FileOutputStream outStream = null;
        try
        {
            inStream = httpUtils.getInputStreamForUrl(url.toString(), new NullProgressMonitor());

            File remoteFile = new File(url.toString());
            String[] remoteFileName = remoteFile.getName().split("\\.");
            cacheIconFile = File.createTempFile(remoteFileName[0], "." + remoteFileName[1]);
            cacheIconFile.deleteOnExit();

            outStream = new FileOutputStream(cacheIconFile);

            byte[] buf = new byte[1024];
            int len;
            while ((len = inStream.read(buf)) > 0)
            {
                outStream.write(buf, 0, len);
            }

        }
        catch (Exception e)
        {
            StudioLogger.error(this.getClass(), "Error while retrieving video thumbnail", e);
        }
        finally
        {
            try
            {
                inStream.close();
                outStream.close();
            }
            catch (Exception e)
            {
                StudioLogger.error(e.getMessage());
            }
        }

        return cacheIconFile;
    }

}