using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Windows;
using MahTweets.Mobile.Core;
using MahTweets.Mobile.Core.Extensions;
using MahTweets.Mobile.Core.Extensions.MahTweets.Core.Extensions;
using MahTweets.Mobile.Core.Interfaces;
using MahTweets.Mobile.Core.LaterReadingProviders;
using MahTweets.Mobile.Core.Repositories;
using MahTweets.Mobile.Core.Services;
using MahTweets.Mobile.MediaProviders;
using MahTweets.Mobile.TwitterPlugin.Models;

namespace MahTweets.Mobile.TwitterPlugin.ViewModels
{
    public class SingleTweetViewModel : MahViewModelBase
    {
        private readonly IStatusUpdatesManager _statusUpdatesManager;
        private readonly ContactRepository _contactRepo;
        private readonly AccountRepository _accountRepository;
        private readonly ThreadSafeObservableCollection<StatusManager> _statusManagers;
        private Twitter _parent;
        private string _id = "";
        private readonly LocationService _locationService;

        public SingleTweetViewModel(
            IStatusUpdatesManager statusUpdatesManager,
            ContactRepository contactRepository,
            AccountRepository accountRepository,
            ThreadSafeObservableCollection<StatusManager> statusManagers,
            LocationService locationService)
        {
            _statusUpdatesManager = statusUpdatesManager;
            _contactRepo = contactRepository;
            _accountRepository = accountRepository;
            _locationService = locationService;
            _statusManagers = statusManagers;
            Conversation = new ThreadSafeObservableCollection<Tweet>();

            Contacts = new ThreadSafeObservableCollection<Contact>();
        }

        public string Id
        {
            get
            {
                return _id;
            }
            set
            {
                _id = value;
                RaisePropertyChanged(() => Id);

                foreach (var s in _statusManagers)
                {
                    var update = s.GetById<Tweet>(_id);
                    if (update == null) 
                        continue;

                    Update = update;
                    break;
                }
            }
        }


        public string Parent
        {
            set
            {
                if (_update == null)
                    return;

                _parent = (Twitter)_accountRepository
                    .Where(p => p.Credentials.AccountName == value)
                    .First();

                if (_update.InReplyToID != null && Conversation.Count == 0)
                    FetchTweet(_update.InReplyToID);
            }
        }

        private Tweet _update;
        public Tweet Update
        {
            get { return _update; }
            set
            {
                _update = value;
                RaisePropertyChanged(() => Update);

            }
        }

        private List<IImageProvider> providers = new List<IImageProvider>() { new TwitpicProvider(), new YFrogProvider()};

        public List<string> Images
        {
            get
            {
                if (_update == null || !_update.HasLinks)
                    return null;

                var images = new List<string>();
                var words = Update.Text.Split(' ');
                foreach (var word in words)
                {
                    if (word.ContainsHyperlink())
                    {
                        foreach (var p in providers)
                        {
                            if (!p.IsMatch(word))
                                continue;

                            images.Add(p.GetImage(word));
                            break;
                        }
                    }
                        
                }

                return images;
            }
        }

        private ThreadSafeObservableCollection<Contact> _contacts;
        public ThreadSafeObservableCollection<Contact> Contacts
        {
            get { return _contacts; }
            set
            {
                _contacts = value;
                RaisePropertyChanged(() => Contacts);
            }
        }

        private void FetchTweet(string latestId)
        {
            var firstTweet = _statusUpdatesManager.GetById<Tweet>(latestId);

            if (firstTweet != null)
            {
                Conversation.Add(firstTweet);
                LockAddContact(firstTweet.Contact);

                if (!string.IsNullOrEmpty(firstTweet.InReplyToID) && firstTweet.InReplyToID != "0")
                {
                    FetchTweet(firstTweet.InReplyToID);
                }
            }
            else
            {
                _parent.TwitterClient.Statuses.BeginGetTweet(latestId, (res, req, obj) =>
                {
                    try
                    {
                        if (obj != null && obj is MahApps.Twitter.Models.Tweet)
                        {
                            var tweet = (MahApps.Twitter.Models.Tweet)obj;

                            var foundContact = Contacts.FirstOrDefault(x => x.Name == tweet.User.ScreenName);
                            if (foundContact == null)
                            {
                                foundContact = _contactRepo.FetchOrCreate(tweet.User.ScreenName);

                                LockAddContact(foundContact);
                            }

                            var t = TwitterHelper.CreateTweet(tweet, foundContact, _parent, null);
                            t.Types.AddUpdate<NormalUpdate>(_parent);
                            Conversation.Add(t);

                            if (!string.IsNullOrEmpty(t.InReplyToID) && t.InReplyToID != "0")
                            {
                                FetchTweet(t.InReplyToID);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        //TODO: Logging
                        Debug.WriteLine(ex.Message);
                    }
                });
            }
        }

        private readonly object _lockObject = new object();
        public void LockAddContact(Contact contact)
        {
            lock (_lockObject)
            {
                if (!Contacts.Contains(contact))
                {
                    Contacts.Add(contact);
                }
            }
        }

        public ThreadSafeObservableCollection<Tweet> Conversation { get; set; }

        public void InstapaperTweet()
        {
            Instapaper.AddWithToast(String.Format("http://twitter.com/{0}/status/{1}", Update.Contact.Name, Update.ID));
        }

        public void Retweet()
        {
            var parent = ((Twitter) Update.Parents.FirstOrDefault());
            if (parent != null)
                parent.Retweet(Update.ID);
        }

        public void Favourite()
        {
            var parent = ((Twitter)Update.Parents.FirstOrDefault());
            if (parent != null)
                parent.Favourite(Update.ID);
        }

        public void Block()
        {
            var parent = ((Twitter)Update.Parents.FirstOrDefault());
            if (parent != null)
                parent.Block(Update.Contact.Name);
        }
    }
}