using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;

using Windows.UI.Xaml.Media.Animation;

// The Basic Page item template is documented at http://go.microsoft.com/fwlink/?LinkId=234237

namespace Save_the_Humans
{
   /// <summary>
   /// A basic page that provides characteristics common to most applications.
   /// </summary>
   public sealed partial class MainPage : Save_the_Humans.Common.LayoutAwarePage
   {
      Random random = new Random();
      DispatcherTimer enemyTimer = new DispatcherTimer();
      DispatcherTimer targetTimer = new DispatcherTimer();
      bool humanCaptured = false;

      public MainPage()
      {
         this.InitializeComponent();

         enemyTimer.Tick += enemyTimer_Tick;
         enemyTimer.Interval = TimeSpan.FromSeconds(2);

         targetTimer.Tick += targetTimer_Tick;
         targetTimer.Interval = TimeSpan.FromSeconds(.1);
      }

      void targetTimer_Tick(object sender, object e)
      {
         progressBar.Value += 1;
         if (progressBar.Value >= progressBar.Maximum)
            EndTheGame();
      }

      private void EndTheGame()
      {
         if (!playArea.Children.Contains(gameOverText))
         {
            enemyTimer.Stop();
            targetTimer.Stop();
            humanCaptured = false;
            startButton.Visibility = Visibility.Visible;
            playArea.Children.Add(gameOverText);
         }
      }

      private void enemyTimer_Tick(object sender, object e)
      {
         AddEnemy();
      }

      /// <summary>
      /// Populates the page with content passed during navigation.  Any saved state is also
      /// provided when recreating a page from a prior session.
      /// </summary>
      /// <param name="navigationParameter">The parameter value passed to
      /// <see cref="Frame.Navigate(Type, Object)"/> when this page was initially requested.
      /// </param>
      /// <param name="pageState">A dictionary of state preserved by this page during an earlier
      /// session.  This will be null the first time a page is visited.</param>
      protected override void LoadState(Object navigationParameter, Dictionary<String, Object> pageState)
      {
      }

      /// <summary>
      /// Preserves state associated with this page in case the application is suspended or the
      /// page is discarded from the navigation cache.  Values must conform to the serialization
      /// requirements of <see cref="SuspensionManager.SessionState"/>.
      /// </summary>
      /// <param name="pageState">An empty dictionary to be populated with serializable state.</param>
      protected override void SaveState(Dictionary<String, Object> pageState)
      {
      }

      private void startButton_Click(object sender, RoutedEventArgs e)
      {
         StartGame();
      }

      private void StartGame()
      {
         human.IsHitTestVisible = true;
         humanCaptured = false;
         progressBar.Value = 0;
         startButton.Visibility = Visibility.Collapsed;
         playArea.Children.Clear();
         playArea.Children.Add(target);
         playArea.Children.Add(human);
         enemyTimer.Start();
         targetTimer.Start();
      }

      private void AddEnemy()
      {
         ContentControl enemy = new ContentControl();
         enemy.Template = Resources["EnemyTemplate"] as ControlTemplate;
         AnimateEnemy(enemy, 0, playArea.ActualWidth - 100, "(Canvas.Left)");
         AnimateEnemy(enemy, random.Next((int)playArea.ActualHeight - 100),
            random.Next((int)playArea.ActualHeight - 100), "(Canvas.Top)");
         playArea.Children.Add(enemy);

         enemy.PointerEntered += enemy_PointerEntered;
      }

      void enemy_PointerEntered(object sender, PointerRoutedEventArgs e)
      {
         if (humanCaptured)
            EndTheGame();
      }

      private void AnimateEnemy(ContentControl enemy, double from, double to, string propertyToAnimate)
      {
         Storyboard storyboard = new Storyboard() { AutoReverse = true, RepeatBehavior = RepeatBehavior.Forever };
         DoubleAnimation animation = new DoubleAnimation()
         {
            From = from,
            To = to,
            Duration = new Duration(TimeSpan.FromSeconds(random.Next(4, 6)))
         };
         Storyboard.SetTarget(animation, enemy);
         Storyboard.SetTargetProperty(animation, propertyToAnimate);
         storyboard.Children.Add(animation);
         storyboard.Begin();
      }

      private void human_PointerPressed(object sender, PointerRoutedEventArgs e)
      {
         if (enemyTimer.IsEnabled)
         {
            humanCaptured = true;
            human.IsHitTestVisible = false;
         }
      }

      private void target_PointerEntered(object sender, PointerRoutedEventArgs e)
      {
         if (targetTimer.IsEnabled && humanCaptured)
         {
            progressBar.Value = 0;
            Canvas.SetLeft(target, random.Next(100, (int)playArea.ActualWidth - 100));
            Canvas.SetTop(target, random.Next(100, (int)playArea.ActualHeight - 100));
            Canvas.SetLeft(human, random.Next(100, (int)playArea.ActualWidth - 100));
            Canvas.SetTop(human, random.Next(100, (int)playArea.ActualHeight - 100));
            humanCaptured = false;
            human.IsHitTestVisible = true;
         }
      }

      private void playArea_PointerMoved(object sender, PointerRoutedEventArgs e)
      {
         if (humanCaptured)
         {
            Point pointerPosition = e.GetCurrentPoint(null).Position;
            Point relativePosition = grid.TransformToVisual(playArea).TransformPoint(pointerPosition);
            if ((Math.Abs(relativePosition.X - Canvas.GetLeft(human)) > human.ActualWidth * 3)
               || (Math.Abs(relativePosition.Y - Canvas.GetTop(human)) > human.ActualHeight * 3))
            {
               humanCaptured = false;
               human.IsHitTestVisible = true;
            }
            else
            {
               Canvas.SetLeft(human, relativePosition.X - human.ActualWidth / 2);
               Canvas.SetTop(human, relativePosition.Y - human.ActualHeight / 2);
            }
         }
      }

      private void playArea_PointerExited(object sender, PointerRoutedEventArgs e)
      {
         if (humanCaptured)
            EndTheGame();
      }

   }
}