package beyondsoft.bewomitarbeiterapp;

import android.app.Activity;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Intent;
import android.graphics.Color;
import android.support.v4.app.NotificationCompat;
import android.os.Bundle;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.Button;

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Timer;
import java.util.TimerTask;


public class MainActivityMitarbeiter extends Activity {

    protected Button dokubutton;
    protected Button chatbutton;
    protected Button logoutbutton;


    //########### Server Relevante Variablen #######################################################
    public static Socket socket;
    protected static final String dstAddress = "192.168.1.117"; //10.0.2.2"
    protected static final  int dstPort = 5000;
    DataOutputStream st;
   public static BufferedReader in = null;
    //Name der Zum Server Gesndet wird
    protected String name;

    //Name der vom Server Erhalten wird
    //protected String recname;

    File file;

    File Unsendfile;

    public static Thread listen;

    public static boolean isThreadPause = false;
    //Für Notification
    private static boolean isOnStop = false;
    private static boolean ankommenderName = false;

    //Testweise
   // protected Map<String,String> MapMessage = new HashMap<>();

    String personoid;
    //##############################################################################################

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main_activity_mitarbeiter);

        setzeButtonListener();

        // Das ist der Name des Grade benutzen devices
        name= "Franz";

        personoid="1";
        //Erstelle für jedes SQLite DatenSatz ein File
        // CreateFile();


        //Starte hier die Server Connection + Daten receive und speichere daten local in den Datensatz
        StartServerConnection();

    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_main_activity_mitarbeiter, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();

        //noinspection SimplifiableIfStatement

        if (id == R.id.action_Logout) {
            System.exit(0);
        }

        return super.onOptionsItemSelected(item);
    }


    public void setzeButtonListener() {

        //################## Kalender Button ######################
        dokubutton = (Button) findViewById(R.id.Dokubutton);
        dokubutton.setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {

                startActivity(new Intent(getBaseContext(),WebdokuActivity.class));

            }
        });

        chatbutton = (Button) findViewById(R.id.Chatbutton);
        chatbutton.setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {

                startActivity(new Intent(getBaseContext(),KontaktChatActivity.class));

            }
        });

        logoutbutton = (Button) findViewById(R.id.Logoutbutton);
        logoutbutton.setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {

               System.exit(0);

            }
        });
    }

//################ Server Gedöns Was im Hintergrund der Gesamten app laufen soll ###################
    public void StartServerConnection(){

        Log.v("Status","Bin in start server connection");
        new Thread(new OpenConnection()).start();

        //Starte hier die Server Connection + Daten receive und speichere daten local in den Datensatz

    }
//##################################################################################################

    public class OpenConnection implements Runnable{
        public void run(){
            try {
                socket = new Socket(dstAddress,dstPort);
                 // Log.v("Status: ","Verbindung wurde aufgebaut");

                //Prüfe und Sende die nicht Gesendeten Nachrichten
                SendAfterGetConnection();

                //nachricht an server senden welcher name jetz aktiv connected ist
                st = new DataOutputStream(socket.getOutputStream());
                name=name+"/1"+"?"+personoid;
                byte[] ts = name.getBytes();
                st.write(ts);
                st.flush();

                // Starte SocketListener
                listen = new Thread(new SocketListener());
                listen.start();

            } catch (Exception e) {
                Log.v("Connection: ","Konnte nicht Aufgebaut werden. Es wird erneut versucht");
                socket = null;
                try {
                    new Timer().schedule(new TimerTask() {
                        @Override
                        public void run() {
                            Log.v("Status", "Starte jetzt den Neu versuch");
                            StartServerConnection();
                        }
                    }, 120000);     //----> Versuche beim Scheitern nach 2 Minuten eine Neue Verbindung aufzubauen
                }catch(Exception s){
                    Log.v("Fehler",s.getMessage());
                    e.printStackTrace();
                }
            }
        }
    }


    public class SocketListener implements Runnable {

        String str;

        public void run() {
            try {
                while (true) {
                        if (socket != null) {
                            if (socket.isConnected()) {    //----------> isThreadPausabfrage dass könnte das problem mit dem Socketlistener vorort beheben
                                if(!isThreadPause){
                                    in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                                    Log.v("Connection Steht ", "Message Erhalten");
                                    String s = in.readLine();

                                    String[] splitt = s.split(":");

                                    str = s;

                                    if (s == null)
                                        break;

                                    Calendar c = Calendar.getInstance();
                                    SimpleDateFormat df = new SimpleDateFormat("dd-MM-yyyy HH:mm:ss");
                                    String formattedDate = df.format(c.getTime());

                                    boolean determind = false;

                                    Log.v("MESSAGE",splitt[0]);
                                    CreateFile(splitt[0]);

                                      //<<<<<<------------ Du ab nach oben
                                        //##############-----------------
                                        Log.v("MESSAGE", "Komme ich den in den Save Bereich Hinein");

                                        WriteMessagesfromStorage(splitt[1] + "/" + determind + "%" + formattedDate + "\n");

                                        SetNotifi(splitt[0], splitt[1]);
                                       // adapter.notifyDataSetChanged();
                                        //#############------------------ mmmmmmmmmaaaaaaaaaaaannnnnnnnn
                                }
                        } else {
                            if (in != null)
                                in.close();
                        }
                    }
                }
            }catch(Exception e){
                Log.v("Status ","Verbindung zum Server wurde seitens dem Server getrennt ");
                // Log.e(getClass().getName(),e.getMessage());
                in = null;
            }
        }
    }

    //##################### Close Connection #######################
    public class ConnectionClose implements Runnable{
        public void run(){
            try {
                if (st != null) {
                    st.flush();
                    st.close();
                }
                if (socket != null)
                    socket.close();

                if(in != null)
                    in = null;

                Log.v("Status","Socket succesfull closed");
            }catch(IOException se){
                Log.v("Fehler Aufgetreten",se.getMessage());
            }
        }
    }
    //##############################################################

    public void CreateFile(String filename){

        try{

            File pfad = getBaseContext().getFilesDir();

            //Für external Save
            //File pfad = getBaseContext().getExternalFilesDir(null);

            //Erstelle das File Objekt
            file = new File(pfad,filename+".txt");

        }catch(Exception e){
            Log.v("Fehler"," Das erstellen/öffnen einer Datei ist Derzeit nicht möglich");
        }
        // WriteMessagesfromStorage("\n ich teste weiter mit  "+name);
    }       //---> Zu sortieren der message zum Jeweiligen kontakt

    public void SendAfterGetConnection(){
        CreateCustomFileForUnSendMessage();

        if(Unsendfile.canRead() && socket.isConnected()){
            try{
                Log.v("Info","Eine ungesendete NAchricht wurde gefunden");

                FileInputStream stream = new FileInputStream(Unsendfile);
                InputStreamReader in = new InputStreamReader(stream);
                BufferedReader readLn = new BufferedReader(in);

                String line = readLn.readLine();
                String allLines="";

                while (line != null) {
                    allLines += line;

                    Log.v("Info","Eine ungesendete NAchricht 4");
                    String[] splitt = line.split("/");

                    if(splitt.length >1 ) {
                        String[] ArtDate = splitt[1].split("%");

                        final String message = splitt[0];
                        final boolean art = Boolean.valueOf(ArtDate[0]);
                        final String datetime = ArtDate[1];

                        Log.v("Info","Eine ungesendete NAchricht 5");
                        //für jede Gelesene Line Sende Nachricht
                        new Thread(new SendUnsendMS(message)).start();
                        Log.v("Info","Eine ungesendete NAchricht 6");
                    }
                    line = readLn.readLine();
                }
                stream.close();
                in.close();
                Unsendfile.delete();
            }catch(Exception fe){
                Log.v("Status","Ein problem ist im BEreich Unsend Ms Aufgetreten");
            }
            //recreate();
        }
    }

    public void CreateCustomFileForUnSendMessage(){
        try{
            File pfad = getBaseContext().getFilesDir();

            //Für external Save
            //File pfad = getBaseContext().getExternalFilesDir(null);

            //Erstelle das File Objekt | name
            Unsendfile = new File(pfad,"hier der name"+"_Unsend"+".txt");

        }catch(Exception e){
            Log.v("Fehler"," Das erstellen/öffnen einer Datei ist Derzeit nicht möglich");
        }
    }

    public class SendUnsendMS implements Runnable{
        String al;
        SendUnsendMS(String unMS){
            this.al = unMS;
        }
        public void run() {
            //String al = text.getText().toString();

            byte[] ts = al.getBytes();
            try {
                if (socket != null && st != null) {

                    //try catch bei catch SaveAfterLoseConnection();
                    st.write(ts);
                    st.flush();
                }
            }catch(Exception xs){
            }
        }
    }

    public void WriteMessagesfromStorage(String message){
        try{

            FileOutputStream stream = new FileOutputStream(file,true);

            try{
                stream.write(message.getBytes());
            }finally {
                stream.close();
            }

            // Log.v("Status","Text: "+message+" wurde gespeichert." );

        }catch (Exception e){
            Log.v("Fehler",e.getMessage());
        }
    }

    //setze Notification
    public void SetNotifi(String Username,String message){

        //Convertiert in Pic Resource in ein Bitmap
        //BitmapFactory.decodeResource(getResources(), R.drawable.bslogo)

        NotificationCompat.Builder mBuilder =
                new NotificationCompat.Builder(this)
                        .setSmallIcon(R.drawable.bslogo)
                        .setContentTitle(Username)
                        .setContentText(message)
                        .setAutoCancel(true)
                        //ab hier neuland
                        .setDefaults(Notification.DEFAULT_SOUND)
                        .setVibrate(new long[] { 1000, 1000, 1000, 1000, 1000 }) //Notification.Default_Vibrate
                        .setLights(Color.YELLOW, 3000, 3000)  //Notification.Default_Lights
                        .setOngoing(true);
        //neuland ende

        Intent resultIntent = new Intent(this, MainActivityMitarbeiter.class);
        //versuch ab hier neuland
        resultIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);
        //neuland ende
        PendingIntent resultPendingIntent =
                PendingIntent.getActivity(
                        this.getApplicationContext(),
                        0,
                        resultIntent,
                        PendingIntent.FLAG_UPDATE_CURRENT

                );
        NotificationManager mNotifyMgr =
                (NotificationManager) getSystemService(NOTIFICATION_SERVICE);


        mBuilder.setContentIntent(resultPendingIntent);

        mNotifyMgr.notify(001, mBuilder.build());
    }

    //###### Activiti abfragen ##################
    public void onResume() {
        // Log.v("Stuss","Hier nochmals on creat aufrufen");
        isOnStop = false;

        super.onResume();
    }

    public void onStop(){
        //  Thread t = new Thread(new ConnectionClose());
        //  t.start();

        isOnStop = true;
        super.onStop();
    }

    public void onDestroy(){
        Thread t = new Thread(new ConnectionClose());
        t.start();

        super.onDestroy();
    }

}
