using System;
using System.Collections.Generic;
using System.Text;
 
namespace ManicDigger.Mods
{
    public class Farbwechselspiel : IMod
    {
        ModManager modManager;
        int spieler;
 
        int blockTypSchwarz;
        int blockTypWeiß;
 
        Position startPosition;
        int ausdehnung = 2;
 
        public void PreStart(ModManager m)
        {
            modManager = m;
            spieler = -1;
 
            startPosition = new Position(0, 0, 0);
 
            blockTypSchwarz = 2;
            blockTypWeiß = 20;
        }
 
        public void Start(ModManager m)
        {
            m.RegisterOnBlockDelete(OnBlockDelete);
            m.RegisterOnPlayerChat(OnPlayerChat);
        }
 
        void OnBlockDelete(int player, int x, int y, int z, int oldblock)
        {
            // gelöschten Block wiederherstellen
            ErstelleBlock(x, y, z, oldblock);
 
            FarbeWechseln(x, y, z, oldblock);
        }
 
        private void FarbeWechseln(int _x, int _y, int _z, int oldblock)
        {
            for (int x = _x - 1; x <= _x + 1; x++)
            {
                for (int y = _y - 1; y <= _y + 1; y++)
                {
                    for (int z = _z - 1; z <= _z + 1; z++)
                    {
                        if (AufFeld(x, y, z) && Benachbart(x, y, z, _x, _y, _z))
                        {
                            BlockTypWechseln(x, y, z);
                        }
                    }
                }
            }
            BlockTypWechseln(_x, _y, _z);
        }
 
        private bool Benachbart(int x1, int y1, int z1, int x2, int y2, int z2)
        {
            return
                // Der Abstand beträgt genau 1
                Math.Pow(x1 - x2, 2) + Math.Pow(y1 - y2, 2) + Math.Pow(z1 - z2, 2) == 1;
        }
 
        private bool AufFeld(int x, int y, int z)
        {
            return
                startPosition.X() <= x &&
                startPosition.X() + ausdehnung > x &&
                startPosition.Y() <= y &&
                startPosition.Y() + ausdehnung > y &&
                startPosition.Z() <= z &&
                startPosition.Z() + ausdehnung > z;
        }
 
        private void BlockTypWechseln(int x, int y, int z)
        {
            if ( SchwarzerBlock(x, y, z) )
            {
                ErstelleBlock(x, y, z, blockTypWeiß);
            }
            else
            {
                ErstelleBlock(x, y, z, blockTypSchwarz);
            }
        }
 
        public bool SchwarzerBlock(int x, int y, int z)
        {
            return modManager.GetBlock(x, y, z) == blockTypSchwarz;
        }
 
        public string OnPlayerChat(int player, string message, bool toteam)
        {
            if(message.Equals("starte Farbwechselspiel"))
            {
                spieler = player;
                startPosition = SpielerPosition().Verschieben(1, 1, 1);
                ErstelleGroßenWürfel(startPosition);
                return "Farbwechselspiel gestartet";
            }
            return "";
        }
 
        private Position SpielerPosition()
        {
            return new Position(
                (int)modManager.GetPlayerPositionX(spieler),
                (int)modManager.GetPlayerPositionY(spieler),
                (int)modManager.GetPlayerPositionZ(spieler));
        }
 
        private void ErstelleGroßenWürfel(Position position)
        {
            for (int x = position.X(); x < position.X() + ausdehnung; x++)
            {
                for (int y = position.Y(); y < position.Y() + ausdehnung; y++)
                {
                    for (int z = position.Z(); z < position.Z() + ausdehnung; z++)
                    {
                        ErstelleBlock(x, y, z, blockTypSchwarz);
                    }
                }
            }
        }
 
        private void ErstelleBlock(int x, int y, int z, int blockTyp)
        {
            modManager.SetBlock(x, y, z, blockTyp);
        }
    }
 
    public class Position
    {
        int x;
        int y;
        int z;
 
        public Position(int x, int y, int z)
        {
            this.x = x;
            this.y = y;
            this.z = z;
        }
 
        public int X()
        {
            return x;
        }
        public int Y()
        {
            return y;
        }
        public int Z()
        {
            return z;
        }
 
        public Position Verschieben(int deltaX, int deltaY, int deltaZ)
        {
            x += deltaX;
            y += deltaY;
            z += deltaZ;
            return this;
        }
    }
}