using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;

namespace WindowsGame1
{
    /// <summary>
    /// This is the main type for your game
    /// </summary>
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;
        //Die Textur der Spieler-Figur: Ein Käfer
        Texture2D Kaefer;
        //Position der Figur
        Vector2 KaeferPosition;
        //Die Textur des Hintergrundes
        Texture2D Hintergrund;
        //Die Textur des Baches
        Texture2D Bach;
        //Die Textur des Gegners: Ein Hai
        Texture2D Hai;
        //Weitere Textur für den Gegener: Flosse
        Texture2D Haiflosse;
        //Position des Hais
        Vector2 Haiposition;
        //Die Textur für eine "Angriffsanimiation"
        Texture2D Wasser;
        //In welche Richtung schwimmt der Hai
        bool HaiNachRechts;
        //Anzahl der Angriffe
        int Haiangriffe;
        //Schrift um die Anzahl anzuzeigen
        SpriteFont font;
        //Farbe für die Schrift
        Color fontColor;
        //Findet gerade ein Angriff statt?
        bool Angriff;
        //Textur-Counter für die Angriffsnanimation
        int AngriffTextur;
        //Textur für Thumbstick
        Texture2D Thumbstick;
        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
            graphics.IsFullScreen = true;
            graphics.PreferredBackBufferHeight = 480;
            graphics.PreferredBackBufferWidth = 800;
            TargetElapsedTime = TimeSpan.FromTicks(333333);
        }

        /// <summary>
        /// Allows the game to perform any initialization it needs to before starting to run.
        /// This is where it can query for any required services and load any non-graphic
        /// related content.  Calling base.Initialize will enumerate through any components
        /// and initialize them as well.
        /// </summary>
        protected override void Initialize()
        {
            // TODO: Add your initialization logic here
            //Den Spieler positionieren
            KaeferPosition.X = 0;
            KaeferPosition.Y = 0;
            //Den Hai positionieren. Die Y Achse wird innerhlab des Spiels nicht verändert
            Haiposition.Y = 200;
            //Die Startrichtung des Hais vorgeben
            HaiNachRechts = true;
            //Spielstatus setzen
            Haiangriffe = 0;
            Angriff = false;
            base.Initialize();
        }

        /// <summary>
        /// LoadContent will be called once per game and is the place to load
        /// all of your content.
        /// </summary>
        protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(GraphicsDevice);
            //Die benötigten Texturen und die Schrift laden
            Kaefer = Content.Load<Texture2D>("Bug");
            Hintergrund = Content.Load<Texture2D>("Hintergrund");
            Bach = Content.Load<Texture2D>("Bachlauf");
            Hai = Content.Load<Texture2D>("Haifisch");
            Haiflosse = Content.Load<Texture2D>("Haifischflosse");
            font = Content.Load<SpriteFont>("SpriteFont1");
            Thumbstick = Content.Load<Texture2D>("xboxControllerLeftThumbstick");
            // TODO: use this.Content to load your game content here
        }

        /// <summary>
        /// UnloadContent will be called once per game and is the place to unload
        /// all content.
        /// </summary>
        protected override void UnloadContent()
        {
            // TODO: Unload any non ContentManager content here
        }

        /// <summary>
        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input, and playing audio.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Update(GameTime gameTime)
        {
            //Beenden über die Back Taste
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                this.Exit();
            //Update der VirtualThumbstick Klasse aufrufen
            VirtualThumbstick.Update();

            if (Keyboard.GetState().IsKeyDown(Keys.Enter) && Keyboard.GetState().IsKeyDown(Keys.LeftAlt))
                graphics.ToggleFullScreen();
            //Cursor Taste: Links + Bewegung des virtuellen Steuerknopfes nach links
            if (Keyboard.GetState().IsKeyDown(Keys.Left) || VirtualThumbstick.LeftThumbstick.X < -0.3f)
            {
                //Auf der X Achse nach links bewegen wenn die Position innerhalb des sichtbaren Bereiches liegt
                if (KaeferPosition.X != 0)
                    KaeferPosition.X -= 2;
            }
            //Cursor Taste: Rechts
            if (Keyboard.GetState().IsKeyDown(Keys.Right) || VirtualThumbstick.LeftThumbstick.X > 0.3f)
            {
                //Auf der X Achse nach rechts bewegen wenn die Position innerhalb des sichtbaren Bereiches liegt
                if (KaeferPosition.X < (graphics.PreferredBackBufferWidth - Kaefer.Width))
                    KaeferPosition.X += 2;
            }
            //Cursor Taste: Oben
            if (Keyboard.GetState().IsKeyDown(Keys.Up) || VirtualThumbstick.LeftThumbstick.Y < -0.3f)
            {
                //Auf der Y Achse nach oben bewegen wenn die Position innerhalb des sichtbaren Bereiches liegt
                if (KaeferPosition.Y != 0)
                    KaeferPosition.Y -= 2;
            }
            //Cursor Taste: Oben
            if (Keyboard.GetState().IsKeyDown(Keys.Down) || VirtualThumbstick.LeftThumbstick.Y > 0.3f)
            {
                //Auf der Y Achse nach unten bewegen wenn die Position innerhalb des sichtbaren Bereiches liegt
                if (KaeferPosition.Y < (graphics.PreferredBackBufferHeight - Kaefer.Height))
                    KaeferPosition.Y += 2;
            }
            //Wenn der Hai ausserhalb des sichtbaren Bereiches ist die Richtung ändern
            if (Haiposition.X > graphics.PreferredBackBufferWidth)
            {
                HaiNachRechts = false;
            }
            else if (Haiposition.X < -Hai.Width)
            {
                HaiNachRechts = true;
            }
            //Die Position in Abhängigkeit der Richtung ändern
            if (HaiNachRechts)
                Haiposition.X += 2;
            else
                Haiposition.X -= 2;

            //Ein Angriff findet statt sobald sich die Rechtecke des Käfers und des Hais überchneiden
            Rectangle HaiRect = new Rectangle((int)Haiposition.X, (int)Haiposition.Y, Hai.Width, Hai.Height);
            Rectangle KaeferRect = new Rectangle((int)KaeferPosition.X, (int)KaeferPosition.Y, Kaefer.Width, Kaefer.Height);
            if (KaeferRect.Intersects(HaiRect))
            {
                if (!Angriff)
                {
                    //Den Angriffszähler hochzählen
                    Haiangriffe += 1;
                    //Angriffsanimation vorbelegen
                    AngriffTextur = 1;
                }
                //Angriff starten
                Angriff = true;
            }
            else
                //Angriff beenden
                Angriff = false;
            //Bei 60 Frames per Second nur alle 20 Frames die Angriffstextur wechseln
            if (Angriff)
            {
                //Angriffstextur und Schriftfarbe wechseln
                int i;
                if (AngriffTextur < 11)
                {
                    fontColor = Color.Red;
                    i = 1;
                }
                else if (AngriffTextur < 21)
                {
                    fontColor = Color.Yellow;
                    i = 2;
                }
                else
                {
                    fontColor = Color.WhiteSmoke;
                    i = 3;
                }
                //Textur laden
                Wasser = Content.Load<Texture2D>("Wasser" + i);
                AngriffTextur++;
                if (AngriffTextur == 31)
                    AngriffTextur = 1;
            }
            else
                fontColor = Color.WhiteSmoke;
            
            base.Update(gameTime);
        }

        /// <summary>
        /// This is called when the game should draw itself.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);

            // TODO: Add your drawing code here
            spriteBatch.Begin();
            //Zuerst den Hintergrund malen. Der eigentlich Bach wird "drübergemalt"
            spriteBatch.Draw(Hintergrund,new Vector2(0,0),new Color(255,255,255,255));
            //Dann kommt der Spieler
            spriteBatch.Draw(Kaefer, KaeferPosition, new Color(255, 255, 255, 255));

            if (!Angriff)
            {
                //Kein Angriff
                // Die Haitextur je nach Richtung drehen
                SpriteEffects HaiEffect;
                if (HaiNachRechts)
                    HaiEffect = SpriteEffects.FlipHorizontally;
                else
                    HaiEffect = SpriteEffects.None;
                spriteBatch.Draw(Hai, Haiposition, null, new Color(255, 255, 255, 80), 0, new Vector2(0, 0), 1.0f, HaiEffect, 0f);
                //Über den Hai den Bach malen
                spriteBatch.Draw(Bach, new Vector2(0, 0), new Color(255, 255, 255, 100));
                //Die Haiflosse über den Bach malen
                spriteBatch.Draw(Haiflosse, Haiposition, null, new Color(255, 255, 255, 255), 0, new Vector2(0, 0), 1.0f, HaiEffect, 0f);
            }
            else
            {
                //Angriff: Bach malen
                spriteBatch.Draw(Bach, new Vector2(0, 0), new Color(255, 255, 255, 100));
                //"Angriffsanimation" malen
                spriteBatch.Draw(Wasser, Haiposition, new Color(255, 255, 255, 255));
            }
            //Anzahl der Angriffe malen
            spriteBatch.DrawString(font, "Haiangriffe: " + Haiangriffe, new Vector2(10, 10), fontColor);
            if (VirtualThumbstick.LeftThumbstickCenter.HasValue)
            {
                Vector2 ThumbPos = new Vector2(VirtualThumbstick.LeftThumbstickCenter.Value.X - (Thumbstick.Width/2),VirtualThumbstick.LeftThumbstickCenter.Value.Y - (Thumbstick.Height/2));
                spriteBatch.Draw(Thumbstick, ThumbPos, new Color(255, 255, 255, 150));
            }
            spriteBatch.End();
            base.Draw(gameTime);
        }
    }
}
