package it.fedeloper.smartcharging.Manager;

/**
 * Created by federico on 22/07/2015.
 */

import android.content.Context;
import android.content.Intent;
import android.location.Address;
import android.location.Geocoder;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Bundle;
import android.os.Handler;
import android.widget.Toast;
import it.fedeloper.smartcharging.R;

import java.io.IOException;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;

public class MyLocation {

    public static Location mylocation = null;
    static Timer timer1;
    static LocationManager locationManager;
    static LocationResult locationResult;
    static boolean gps_enabled = false;
    static boolean network_enabled = false;
    static boolean passive_enabled = false;
static int countGps =0;
    private static boolean gpsToastShownOnce = false;

    /**
     * Check if gps is enabled, show a toast when disabled
     *
     * @param context context (this in Activity / getActivity() in Fragment)
     * @return true if gps is enabled
     */
    public static boolean isGpsEnabled(final Context context,boolean showToast) {
        LocationManager locationManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
        Boolean isGpsEnabled = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
        if (!isGpsEnabled) {
            if(!gpsToastShownOnce){
               if (showToast) Utils.toast(context, R.string.enable_gps_toast);
                gpsToastShownOnce = true;
            }
            if (countGps == 0)
                countGps++;
            else if (countGps == 1) {
                countGps++;
            }
        }
        return isGpsEnabled;

    }
    static LocationListener locationListenerPassive = new LocationListener() {
        public void onLocationChanged(Location location) {
            timer1.cancel();
            mylocation = location;
            locationResult.gotLocation(location);
            locationManager.removeUpdates(this);
            locationManager.removeUpdates(locationListenerGps);
            locationManager.removeUpdates(locationListenerNetwork);
        }
        public void onProviderDisabled(String provider) {}
        public void onProviderEnabled(String provider) {}
        public void onStatusChanged(String provider, int status, Bundle extras) {}
    };

    static LocationListener locationListenerNetwork = new LocationListener() {
        public void onLocationChanged(Location location) {
            timer1.cancel();
            mylocation = location;
            locationResult.gotLocation(location);
            locationManager.removeUpdates(this);
            locationManager.removeUpdates(locationListenerGps);
            locationManager.removeUpdates(locationListenerPassive);
        }
        public void onProviderDisabled(String provider) {
        }

        public void onProviderEnabled(String provider) {
        }

        public void onStatusChanged(String provider, int status, Bundle extras) {
        }
    };

    static LocationListener locationListenerGps = new LocationListener() {
        public void onLocationChanged(Location location) {
            timer1.cancel();
            mylocation = location;
            locationResult.gotLocation(location);
            locationManager.removeUpdates(this);
            locationManager.removeUpdates(locationListenerNetwork);
            locationManager.removeUpdates(locationListenerPassive);
        }

        public void onProviderDisabled(String provider) {
        }

        public void onProviderEnabled(String provider) {
        }

        public void onStatusChanged(String provider, int status, Bundle extras) {
        }
    };

    public static boolean getLocation(Context context, LocationResult result) {

        isGpsEnabled(context,true);
        if (mylocation == null) {
            //I use LocationResult callback class to pass location value from MyLocation to user code.
            locationResult = result;
            if (locationManager == null)
                locationManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);

            //exceptions will be thrown if provider is not permitted.
            try {
                gps_enabled = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
            } catch (Exception ex) {
            }
            try {
                network_enabled = locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
            } catch (Exception ex) {
            }
            try {
                network_enabled = locationManager.isProviderEnabled(LocationManager.PASSIVE_PROVIDER);
            } catch (Exception ex) {
            }

            if (passive_enabled && locationManager.getLastKnownLocation(LocationManager.PASSIVE_PROVIDER) != null) {
                locationResult.gotLocation(locationManager.getLastKnownLocation(LocationManager.PASSIVE_PROVIDER));
            } else {
                //don't start listeners if no provider is enabled
                if (!gps_enabled && !network_enabled)
                    return false;

                if (gps_enabled)
                    locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, locationListenerGps);
                if (network_enabled)
                    locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0, locationListenerNetwork);
                if (passive_enabled)
                    locationManager.requestLocationUpdates(LocationManager.PASSIVE_PROVIDER, 0, 0, locationListenerPassive);
                timer1 = new Timer();
                timer1.schedule(new GetLastLocation(), 20000);
            }
        } else {
            locationResult = result;
            locationResult.gotLocation(mylocation);
        }


        return true;
    }

    public static Address getAddress(final Context context, final Location location) {
        if (location == null)
            return null;

        final Geocoder geocoder = new Geocoder(context);
        final List<Address> addresses;
        try {
            addresses = geocoder.getFromLocation(location.getLatitude(),
                    location.getLongitude(), 1);
        } catch (IOException e) {
            return null;
        }
        if (addresses != null && !addresses.isEmpty())
            return addresses.get(0);
        else
            return null;
    }

    static class GetLastLocation extends TimerTask {
        @Override
        public void run() {
            locationManager.removeUpdates(locationListenerGps);
            locationManager.removeUpdates(locationListenerNetwork);
            locationManager.removeUpdates(locationListenerPassive);
            Location net_loc = null, gps_loc = null;
            if (gps_enabled)
                gps_loc = locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);
            if (network_enabled)
                net_loc = locationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);

            //if there are both values use the latest one
            if (gps_loc != null && net_loc != null) {
                if (gps_loc.getTime() > net_loc.getTime()) {
                    mylocation = gps_loc;
                    locationResult.gotLocation(gps_loc);
                } else {
                    mylocation = net_loc;
                    locationResult.gotLocation(net_loc);
                }

                return;
            }

            if (gps_loc != null) {
                mylocation = gps_loc;
                locationResult.gotLocation(gps_loc);
                return;
            }
            if (net_loc != null) {
                mylocation = net_loc;
                locationResult.gotLocation(net_loc);
                return;
            }
            locationResult.gotLocation(null);
        }
    }

    public static abstract class LocationResult {
        public abstract void gotLocation(Location location);
    }


}