package com.gokdemir.areyousafe;

import android.annotation.SuppressLint;
import android.app.Service;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.location.Location;
import android.net.wifi.WpsInfo;
import android.net.wifi.p2p.WifiP2pConfig;
import android.net.wifi.p2p.WifiP2pDevice;
import android.net.wifi.p2p.WifiP2pDeviceList;
import android.net.wifi.p2p.WifiP2pGroup;
import android.net.wifi.p2p.WifiP2pInfo;
import android.net.wifi.p2p.WifiP2pManager;
import android.net.wifi.p2p.nsd.WifiP2pDnsSdServiceInfo;
import android.net.wifi.p2p.nsd.WifiP2pDnsSdServiceRequest;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.support.annotation.Nullable;
import android.util.Log;

import com.android.volley.Request;
import com.android.volley.RequestQueue;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.StringRequest;
import com.android.volley.toolbox.Volley;
import com.couchbase.lite.CouchbaseLiteException;
import com.couchbase.lite.Database;
import com.couchbase.lite.Document;
import com.couchbase.lite.Manager;
import com.couchbase.lite.Query;
import com.couchbase.lite.QueryEnumerator;
import com.couchbase.lite.QueryRow;
import com.couchbase.lite.UnsavedRevision;
import com.couchbase.lite.android.AndroidContext;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserFactory;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.reflect.Method;
import java.net.Inet4Address;
import java.net.ServerSocket;
import java.net.Socket;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

import static com.gokdemir.areyousafe.BuildConfig.DEBUG;

/**
 * Created by yatba on 14-Nov-17.
 */

public class P2PService  extends Service{
    private String[] TAGS;
    // TXT RECORD properties
    public List<NearbyDevice> devicesNearby= new ArrayList<>();
    AndroidContext androidContext;
    LocalDatabaseHandler handler;
    public static final String TXTRECORD_PROP_AVAILABLE = "available";
    public static final String SERVICE_INSTANCE = "_areyousafe";
    public static final String SERVICE_REG_TYPE = "_presence._tcp";
    private WifiP2pDnsSdServiceRequest serviceRequest;
    private String deviceMacs="";
    WifiP2pManager mManager;
    WifiP2pManager.Channel mChannel;
    BroadcastReceiver mReceiver;
    IntentFilter mIntentFilter;


    private ServerSocket mServerSocket;
    private Integer mLocalPort;
    private Database db;
    private boolean isConnected;
    private  boolean isGroupOwner;
    private  boolean isGroupCreated;
    private static Integer user_num= 0;


    private Future<?> timingTask;
    private final ScheduledExecutorService scheduler =
            Executors.newSingleThreadScheduledExecutor();

    public void nearbyDeviceInfo()
    {
        VolleyHandler handler = new VolleyHandler();
        Log.d("Nearby Info",String.valueOf(deviceMacs.equals("")));
        handler.setNearbys(deviceMacs);

    }
    public void tick(long milliseconds, final LocalDatabaseHandler handler) {
        timingTask = scheduler.scheduleAtFixedRate(new Runnable() {
            @SuppressLint("MissingPermission")
            public void run() {

                try {
                    discoverService();
                    nearbyDeviceInfo();

                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },0,milliseconds, TimeUnit.MILLISECONDS);
    }



    private void discoverService() {
        mManager.setDnsSdResponseListeners(mChannel, new WifiP2pManager.DnsSdServiceResponseListener() {
            @Override
            public void onDnsSdServiceAvailable(String instanceName, String registrationType, WifiP2pDevice wifiP2pDevice) {
                obtainNearbyServices(instanceName, registrationType, wifiP2pDevice);
            }
        }, new WifiP2pManager.DnsSdTxtRecordListener() {
            @Override
            public void onDnsSdTxtRecordAvailable(String s, Map<String, String> map, WifiP2pDevice wifiP2pDevice) {
            }
        });
        serviceRequest = WifiP2pDnsSdServiceRequest.newInstance();
        mManager.addServiceRequest(mChannel, serviceRequest, new WifiP2pManager.ActionListener() {
            @Override
            public void onSuccess() {
                appendStatus("Added service discovery Request");
            }

            @Override
            public void onFailure(int i) {
                appendStatus("Failed service discovery Request");
            }
        });
        mManager.discoverServices(mChannel, new WifiP2pManager.ActionListener() {
            @Override
            public void onSuccess() {
                appendStatus("Service discovery Succeeded!");
            }

            @Override
            public void onFailure(int i) {
                appendStatus("Service discovery Failed!");
            }
        });
    }

    private void obtainNearbyServices(String instanceName, String registrationType, WifiP2pDevice wifiP2pDevice) {
        Log.d("Founded device",instanceName +" " +SERVICE_INSTANCE);
        if(instanceName.equalsIgnoreCase(SERVICE_INSTANCE))
        {

            NearbyDevice temp = new NearbyDevice(wifiP2pDevice.deviceAddress,new Location(""),
                    registrationType,wifiP2pDevice.deviceName);
            Log.d("Found",temp.getDeviceAddress());
            if(!deviceMacs.contains(temp.getDeviceAddress())) {
                deviceMacs+=temp.getDeviceAddress() +";";
            }
            Log.d("Devices nearby",deviceMacs) ;
        }
    }


    private void startRegistrationAndDiscovery() {
        SessionManager temp= new SessionManager(getApplicationContext());
        Map record = new HashMap();
        record.put(TXTRECORD_PROP_AVAILABLE, "visible");

        /*
        Service information.  Pass it an instance name, service type
        _protocol._transportlayer , and the map containing
        information other devices will want once they connect to this one.
        */
        WifiP2pDnsSdServiceInfo serviceInfo = WifiP2pDnsSdServiceInfo.newInstance(SERVICE_INSTANCE, SERVICE_REG_TYPE, record);
        mManager.addLocalService(mChannel, serviceInfo, new WifiP2pManager.ActionListener() {
            @Override
            public void onSuccess() {
                Log.i(TAGS[7], "Successfully added the service!!");
            }

            @Override
            public void onFailure(int i) {
                Log.i(TAGS[7], String.valueOf(i));
            }
        });
        discoverService();

    }
    //--------------------------------------------------------------------------------------------------------------------------------
    //End
    public void appendStatus(String status) {
        Log.d("P2P Service",status);
    }

    @Override
    public void onCreate()
    {
        initalizeElements();
        registerReceiver(mReceiver,mIntentFilter);

        //initializeServerSocket();
        startRegistrationAndDiscovery();
        tick(3*60000,handler);



    }

    private void initalizeElements() {
        TAGS =getResources().getStringArray(R.array.p2p_debug_tags);
        isConnected = false;
        isGroupCreated = false;

        androidContext = new AndroidContext(getApplicationContext());
        handler = new LocalDatabaseHandler(androidContext);

        mIntentFilter = new IntentFilter();
        mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);
        mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION);
        mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);
        mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);
        mManager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);
        mChannel = mManager.initialize(this, getMainLooper(), null);
        mReceiver = new WiFiDirectBroadcastReceiver(mManager,mChannel,this);
    }

    @Override
    public IBinder onBind(Intent intent)
    {
        return null;
    }
}