package beta.calculator.facebamm.dbaum.calculator.demo;

import android.content.Context;
import android.content.DialogInterface;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.support.v7.app.AlertDialog;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
import android.widget.ArrayAdapter;
import android.widget.EditText;
import android.widget.LinearLayout;
import android.widget.ListView;
import android.widget.TextView;

import java.util.ArrayList;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Created by DBaum on 11.10.2015.
 */
public class GraphPlotter {

    private KordinatenSystem KordinatenSystem;
    private Context ctx;
    private ArrayList<Funktion> Funktionen;
    private HelpToolBox helpBox;
    private Patter patterStg;
    public  GraphPlotter(Context context)
    {
        ctx = context;
        helpBox = new HelpToolBox(ctx);
        KordinatenSystem = new KordinatenSystem(ctx);
        Funktionen = new ArrayList<>();
        patterStg = new Patter();
    }
    public void setStep(float x,float y)
    {
        KordinatenSystem.setStep(x,y);
    }
    public KordinatenSystem getKordinatenSystem()
    {
        return KordinatenSystem;
    }
    private void addFunction(String Funktion)
    {

        Funktionen.add(new indikateString().scan(Funktion));
        KordinatenSystem.invalidate();
    }

    public void Add_AlertDialogBuilder(final LinearLayout Lay)
    {

        final String[] Items = new String[] {"Point","Konstante"};
        ListView Liste = new ListView(ctx);
        AlertDialog.Builder Dialog = helpBox.getAlertDialogBuilder("Add...","",Liste);
        ArrayAdapter<String> arrayAdapterItems = new ArrayAdapter<String>(ctx,android.R.layout.simple_expandable_list_item_1, Items);

        Dialog.setAdapter(arrayAdapterItems, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                switch (which) {
                    case 0:
                        final View v = helpBox.getView(R.layout.dialog_point);
                        AlertDialog.Builder Pointer = helpBox.getAlertDialogBuilder("Pointer", "", v);
                        Pointer.setPositiveButton("Finish", new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialog, int which) {
                                EditText na = (EditText) v.findViewById(R.id.dialogPointer_Name);
                                EditText kx = (EditText) v.findViewById(R.id.dialogPointer_x);
                                EditText ky = (EditText) v.findViewById(R.id.dialogPointer_y);

                                String Fun = String.format("%s=(%s/%s)", na.getText(), kx.getText(), ky.getText());

                                TextView Tv = (TextView) helpBox.getView(R.layout.your_custom_view).findViewById(R.id.LabelText);
                                Tv.setText(Fun);
                                Tv.setOnClickListener(new View.OnClickListener() {
                                    @Override
                                    public void onClick(View v) {
                                        //TODO Lösch Dialog und Bearbeitn Dialog
                                    }
                                });
                                int Posi = Lay.getChildCount();
                                Lay.addView(Tv, Posi - 1);

                                addFunction(Fun);
                            }
                        });
                        Pointer.setNegativeButton("Canel", null);
                        Pointer.create().show();
                    case 1:
                }
            }
        }) ;
        Dialog.setPositiveButton("Finish",null);
        Dialog.create().show();
    }



  private class indikateString {
      private String Funktion;

      public Funktion scan(String Funk) {

          Funktion = Funk;
          String Typ = checkString();
          float[] Werte = getWerte(Typ);
          return new Funktion(Typ,Funktion,Werte);
      }

      private String checkString()
      {
          if(Funktion.matches(patterStg.PointPatter))
              return patterStg.PointPatter;
          if (Funktion.matches(patterStg.KonstantenPatter))
              return patterStg.KonstantenPatter;

          return "Null";
      }

      private float[] getWerte(String patter)
      {
          Pattern p = Pattern.compile(patter);
          Matcher m = p.matcher(Funktion);
          float[] Werte = new float[m.groupCount()];
          int selection = 0;
          while(m.find())
          {
              Werte[selection] = helpBox.STRGtoFloat(m.group()) ;
              selection++;
          }

          return  Werte;
      }
  }

    private class Funktion
    {
        public String Typ;
        public String Aufgabe;
        public float[] Werte;
        public Paint color;
        private Random R;
        public Funktion(String Typ,String Aufgabe, float[] Wert)
        {
            this.Typ = Typ;
            this.Aufgabe = Aufgabe;
            this.Werte = Wert;

            R = new Random();
            color = new Paint();
            color.setColor(Color.argb(255,R.nextInt(255),R.nextInt(255),R.nextInt(255)));
        }
        public Funktion(String Typ,String Aufgabe, float[] Wert,Paint Color)
        {
            this.Typ = Typ;
            this.Aufgabe = Aufgabe;
            this.Werte = Wert;
            color = Color;
        }
    }
    public class Patter {
        public static final String Zahl = "\\-?\\d+\\.?\\d+|\\-?\\d+";
        public static final String PointPatter = "([\\w])=\\((\\-?\\d+\\.?\\d+|\\-?\\d+)\\/(\\-?\\d+\\.?\\d+|\\-?\\d+)\\)";
        public static final String KonstantenPatter = "([\\w])?\\=(\\-?\\d+\\.?\\d+|\\-?\\d+)";
    }
    //region GraphPlotterView
    public class KordinatenSystem extends View {
        private Context ctx;
        private Bitmap mBitmap;
        private int width;
        private int height;
        private float[] step;
        private float[] verschiebung;
        private float[] mitte;
        private Patter patternString = new Patter();
        public ArrayList<String> Texte,PointerTxT;

        //region OnLoad
        public KordinatenSystem(Context context) {
            super(context);
            ctx = context;
            start();
        }

        public KordinatenSystem(Context context, AttributeSet attrs) {
            super(context, attrs);
            ctx = context;
            start();
        }

        private void start()
        {

            verschiebung = new float[]{0,0};
            Texte = new ArrayList<>();
            PointerTxT = new ArrayList<>();
        }
        //endregion

        //region Enstellung
        public void setStep(float x,float y)
        {
            step = new float[]{x,y};
            invalidate();
        }
        //endregion

        //region Canvas
        @Override
        protected void onDraw(Canvas canvas) {
            super.onDraw(canvas);

            //region Kordinatensystem Zeichnen
            float count_w = 0;
            float count_h = 0;

            Paint mPaint = new Paint();
            mPaint.setColor(Color.RED);
            mPaint.setStrokeWidth(2f);

            Paint middlePaint = new Paint();
            middlePaint.setStrokeWidth(6f);
            middlePaint.setColor(Color.RED);


            float stepx =  (width/step[0]);
            float stepy =  (stepx*step[1])/step[0]; //(height / step[1]);

            for (float i = 1; i <= width + 1; i = i + stepx) {
                float xs = verschiebung[0] % stepx;
                canvas.drawLine(i + xs, 0, i + xs, height, mPaint);
                count_w++;
            }

            for (float i = 1; i <= height + 1; i = i + stepy) {
                float ys = verschiebung[1] % stepy;
                canvas.drawLine(0, i + ys, width, i + ys, mPaint);
                count_h++;
            }

            float mittex = count_w / 2 * stepx;
            float mittey = count_h / 2 * stepy;

            if ((int)mittex % 2 == 0) {
                Log.d("bbx", String.valueOf((int) mittex));
                mittex = mittex - (stepx / 2);
            }

            if (step[1] % 2 == 0) {
                Log.d("bby", String.valueOf((int) mittey));
                mittey = mittey - (stepy / 2);
            }
            mitte = new float[]{mittex + verschiebung[0],mittey + verschiebung[1]};
            canvas.drawLine(mitte[0], 0, mitte[0], height, middlePaint);
            canvas.drawLine(0,mitte[1] , width,mitte[1], middlePaint);
            //endregion

            //region Zeichnen der Einzelnen Funktionen
            if(Funktionen != null) {
                int pCount = Funktionen.size()- 1;
                for (int i = 0; i <= pCount; i++) {
                    Funktion Item = Funktionen.get(i);
                    switch (Item.Typ)
                    {
                        case Patter.PointPatter:
                            float Px = (Item.Werte[1] * stepx) + mitte[0];
                            float Py = (Item.Werte[2] * stepy) + mitte[1];
                            Log.d("Point", String.valueOf("S(" + Px + "|" + Py + ")"));
                            canvas.drawLine(Px - 15, Py - 15, Px + 15, Py + 15, Item.color);
                            canvas.drawLine(Px + 15, Py - 15, Px - 15, Py + 15, Item.color);
                            break;
                        //case :
                        //    P_to_PFun p2p = Item.P2P_Fun;
                        //    float Startx = -500f;
                        //    float Endx = 500f;
                        //    float starty = (p2p.m * Startx) + p2p.n;
                        //    float endy = (p2p.m * (Startx*-1)) + p2p.n;
                        //    canvas.drawLine(
                        //            (Startx * stepx) + mitte[0],(starty* stepx) + mitte[1],
                        //            (Endx * stepx) + mitte[0],(endy* stepx) + mitte[1],Item.pointerC);
                        //    break;
                    }
                }
            }
            //endregion
        }
        //endregion

        //region GrößenVeränderung
        @Override
        protected void onSizeChanged(int w, int h, int oldw, int oldh) {
            super.onSizeChanged(w, h, oldw, oldh);
            mBitmap = Bitmap.createBitmap(w,h,Bitmap.Config.ARGB_8888);
            height = h;
            width = w;
        }
        //endregion

        //region Touchbewegung
        private float px,py;
        private float touchx,touchy;
        private static final int INVALID_POINTER_ID = -1;
        private int ActivePointer = INVALID_POINTER_ID;
        private int newActivePointer = INVALID_POINTER_ID;

        @Override
        public boolean onTouchEvent(MotionEvent event) {
            int PointerC = event.getPointerCount();
            switch(PointerC) {
                case 1:
                    //region EinzelnerTouch
                    switch (event.getActionMasked()) {
                        case MotionEvent.ACTION_DOWN:
                            px = verschiebung[0];
                            py = verschiebung[1];
                            touchx = event.getRawX();
                            touchy = event.getRawY();
                            break;
                        case MotionEvent.ACTION_MOVE:
                            verschiebung[0] = ((px + (event.getRawX() - touchx)));
                            verschiebung[1] = ((py + (event.getRawY() - touchy)));
                            break;
                    }
                    break;
                //endregion
                case 2:

                    //region MultiTouch
                    switch(event.getActionMasked())
                    {
                        case MotionEvent.ACTION_DOWN:
                            if (ActivePointer == INVALID_POINTER_ID) {
                                ActivePointer = event.getPointerId(0);
                            } else {
                                newActivePointer = event.getPointerId(1);
                            }
                            break;
                        case MotionEvent.ACTION_MOVE:
                            break;
                        case MotionEvent.ACTION_CANCEL:
                            ActivePointer = INVALID_POINTER_ID;
                            newActivePointer = INVALID_POINTER_ID;
                            break;
                    }
                    //endregion
            }
            invalidate();
            return true;
        }
        //endregion

    }
    //endregion


}