package net.cloudninedev.routeplanner;

import android.content.Intent;
import android.graphics.Color;
import android.net.Uri;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.design.widget.FloatingActionButton;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.Gravity;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.Toast;

import com.anjlab.android.iab.v3.BillingProcessor;
import com.anjlab.android.iab.v3.TransactionDetails;
import com.appodeal.ads.Appodeal;
import com.appodeal.ads.InterstitialCallbacks;
import com.google.android.gms.appinvite.AppInviteInvitation;
import com.mapbox.android.core.location.LocationEngine;
import com.mapbox.android.core.location.LocationEngineProvider;
import com.mapbox.api.directions.v5.models.DirectionsResponse;
import com.mapbox.geojson.LineString;
import com.mapbox.geojson.Point;
import com.mapbox.mapboxsdk.Mapbox;
import com.mapbox.mapboxsdk.annotations.MarkerOptions;
import com.mapbox.mapboxsdk.annotations.Polyline;
import com.mapbox.mapboxsdk.annotations.PolylineOptions;
import com.mapbox.mapboxsdk.camera.CameraPosition;
import com.mapbox.mapboxsdk.camera.CameraUpdateFactory;
import com.mapbox.mapboxsdk.geometry.LatLng;
import com.mapbox.mapboxsdk.maps.MapView;
import com.mapbox.mapboxsdk.maps.MapboxMap;
import com.mapbox.mapboxsdk.maps.OnMapReadyCallback;
import com.mapbox.services.android.navigation.ui.v5.NavigationLauncher;
import com.mapbox.services.android.navigation.ui.v5.NavigationLauncherOptions;
import com.mapbox.services.android.navigation.v5.navigation.MapboxNavigation;
import com.mapbox.services.android.navigation.v5.navigation.NavigationRoute;
import com.mapbox.services.api.directions.v5.DirectionsCriteria;
import com.mapbox.services.api.directions.v5.models.DirectionsRoute;
import com.mapbox.services.api.directions.v5.models.DirectionsWaypoint;
import com.mapbox.services.api.optimizedtrips.v1.MapboxOptimizedTrips;
import com.mapbox.services.api.optimizedtrips.v1.models.OptimizedTripsResponse;
import com.mapbox.services.commons.models.Position;

import java.util.ArrayList;
import java.util.List;

import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;

import static com.mapbox.services.Constants.PRECISION_6;

public class MapActivity extends AppCompatActivity implements BillingProcessor.IBillingHandler, OnMapReadyCallback {
    private MapView mapView;
    private MapboxMap mapboxMap;
    private DirectionsRoute optimizedRoute;
    private MapboxOptimizedTrips optimizedClient;
    private Polyline optimizedPolyline;
    private List<String> stopAddresses = new ArrayList<String>();
    private List<Position> stops = new ArrayList<Position>();

    private FloatingActionButton fab;
    private MapboxNavigation mapboxNavigation;
    private LocationEngine locationEngine;
    private List<DirectionsWaypoint> optimizedWayponints = new ArrayList<>();

    private static final String WHITE_COLOR = "#FFFFFF";
    private static final int POLYLINE_WIDTH = 5;

    private static final String PRODUCT_ID = "ad_free";
    private BillingProcessor billingProcessor;
    private boolean readyToPurchase = false;

    private static final int REQUEST_INVITE = 1892;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Appodeal.setTesting(false);
        String appKey = "60cc29826cf38be341927f662556b6275bc2727377b2fb59";
        Appodeal.initialize(this, appKey, Appodeal.INTERSTITIAL, true);

        Mapbox.getInstance(this, "pk.eyJ1Ijoid3NhdmVyaWxsIiwiYSI6ImNqbWlueTY4ODA0ODAza2txNzQyMHFhanQifQ.MaPSs93xzh4lJqkf6yBncw");
        setContentView(R.layout.activity_map);

        mapboxNavigation = new MapboxNavigation(this, "pk.eyJ1Ijoid3NhdmVyaWxsIiwiYSI6ImNqbWlueTY4ODA0ODAza2txNzQyMHFhanQifQ.MaPSs93xzh4lJqkf6yBncw");
        locationEngine = new LocationEngineProvider(this).obtainBestLocationEngineAvailable();
        mapboxNavigation.setLocationEngine(locationEngine);

        mapView = (MapView) findViewById(R.id.mapView);
        mapView.onCreate(savedInstanceState);
        mapView.getMapAsync(this);

        Bundle bundle = getIntent().getExtras();

        for (int i = 0; i < bundle.getInt("Number of Stops"); i++) {
            stopAddresses.add(bundle.getString("Stop " + (i + 1) + " Address"));
            stops.add(Position.fromCoordinates(bundle.getDouble("Stop " + (i + 1) + " Longitude"), bundle.getDouble("Stop " + (i + 1) + " Latitude")));
        }

        fab = findViewById(R.id.fab);
        fab.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View view) {
                NavigationRoute.Builder builder = NavigationRoute.builder(getApplicationContext())
                        .accessToken(Mapbox.getAccessToken())
                        .origin(Point.fromLngLat(optimizedWayponints.get(0).asPosition().getLongitude(), optimizedWayponints.get(0).asPosition().getLatitude()))
                        .destination(Point.fromLngLat(optimizedWayponints.get(optimizedWayponints.size()-1).asPosition().getLongitude(), optimizedWayponints.get(optimizedWayponints.size()-1).asPosition().getLatitude()))
                        .profile(DirectionsCriteria.PROFILE_DRIVING);

                for (int i = 1; i < optimizedWayponints.size()-1; i++) {
                    builder.addWaypoint(Point.fromLngLat(optimizedWayponints.get(i).asPosition().getLongitude(), optimizedWayponints.get(i).asPosition().getLatitude()));
                }

                builder.build().getRoute(new Callback<DirectionsResponse>() {

                    @Override
                    public void onResponse(Call<DirectionsResponse> call, Response<DirectionsResponse> response) {
                        NavigationLauncherOptions options = NavigationLauncherOptions.builder()
                                .directionsRoute(response.body().routes().get(0))
                                .shouldSimulateRoute(false)
                                .build();

                        NavigationLauncher.startNavigation(MapActivity.this, options);
                    }

                    @Override
                    public void onFailure(Call<DirectionsResponse> call, Throwable t) {

                    }
                });
            }
        });

        if (!BillingProcessor.isIabServiceAvailable(this)) {
            Toast toast = Toast.makeText(getApplicationContext(), getString(R.string.billing_service_unavailable), Toast.LENGTH_LONG);
            toast.setGravity(Gravity.CENTER, 0, 0);
            toast.show();
        }

        billingProcessor = new BillingProcessor(this, getString(R.string.license_key), null, this);
    }

    @Override
    public void onProductPurchased(@NonNull String productId, @Nullable TransactionDetails details) {

        if (billingProcessor.isPurchased(PRODUCT_ID)) {
            hideAd();
        } else {
            showAd();
        }
    }

    @Override
    public void onBillingError(int errorCode, @Nullable Throwable error) {

        if (error != null) {
            error.printStackTrace();
        }
    }

    @Override
    public void onBillingInitialized() {

        if (billingProcessor.isPurchased(PRODUCT_ID)) {
            hideAd();
        } else {
            showAd();
        }
    }

    @Override
    public void onPurchaseHistoryRestored() {

        for (String sku : billingProcessor.listOwnedProducts()) {

            if (sku.equals(PRODUCT_ID)) {
                hideAd();
            }
        }
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.menu_map, menu);

        return super.onCreateOptionsMenu(menu);
    }

    @Override
    public boolean onPrepareOptionsMenu(Menu menu) {
        final boolean show = super.onPrepareOptionsMenu(menu);
        menu.findItem(R.id.shopping_cart).setEnabled(readyToPurchase);

        return show;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {

        switch (item.getItemId()) {

            case R.id.shopping_cart:
                buyAdFree();

                return true;

            case R.id.share:
                Intent intent = new AppInviteInvitation.IntentBuilder(getString(R.string.invitation_title))
                        .setMessage(getString(R.string.invitation_message))
                        .setDeepLink(Uri.parse(getString(R.string.invitation_deep_link)))
                        .build();
                startActivityForResult(intent, REQUEST_INVITE);

                return true;

            case R.id.privacy_policy:
                Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse("https://leveltap.wixsite.com/routeplanner"));
                startActivity(browserIntent);

                return true;

            default:

                return super.onOptionsItemSelected(item);
        }
    }

    @Override
    public void onMapReady(MapboxMap mapboxMap) {
        MapActivity.this.mapboxMap = mapboxMap;

        CameraPosition position = new CameraPosition.Builder()
                .target(new LatLng(stops.get(0).getLatitude(), stops.get(0).getLongitude()))
                .zoom(10)
                .bearing(0)
                .tilt(0)
                .build();

        mapboxMap.animateCamera(CameraUpdateFactory.newCameraPosition(position), 1000);

        for (int i = 0; i < stops.size(); i++) {
            mapboxMap.addMarker(new MarkerOptions()
                            .position(new LatLng(stops.get(i).getLatitude(),stops.get(i).getLongitude()))
                            .title("" + (i+1))
                            .snippet(stopAddresses.get(i)));
        }

        optimizedClient = new MapboxOptimizedTrips.Builder()
                .setProfile(DirectionsCriteria.PROFILE_DRIVING)
                .setAccessToken(Mapbox.getAccessToken())
                .setCoordinates(new ArrayList<Position>(stops))
                .build();

        optimizedClient.enqueueCall(new Callback<OptimizedTripsResponse>() {

            @Override
            public void onResponse(Call<OptimizedTripsResponse> call, Response<OptimizedTripsResponse> response) {
                if (!response.isSuccessful()) {
                    Log.d("MapActivity", getString(R.string.no_success));
                    Toast.makeText(MapActivity.this, R.string.no_success, Toast.LENGTH_SHORT).show();
                    return;
                } else {
                    if (response.body().getTrips().isEmpty()) {
                        Log.d("MapActivity", getString(R.string.successful_but_no_routes) + " size = "
                                + response.body().getTrips().size());
                        Toast.makeText(MapActivity.this, R.string.successful_but_no_routes,
                                Toast.LENGTH_SHORT).show();
                        return;
                    }
                }

                // Get most optimized route from API response
                optimizedRoute = response.body().getTrips().get(0);
                drawOptimizedRoute(optimizedRoute);

                for (int i = 0; i < response.body().getWaypoints().size(); i++) {
                    optimizedWayponints.add(response.body().getWaypoints().get(i));
                }
            }

            @Override
            public void onFailure(Call<OptimizedTripsResponse> call, Throwable throwable) {
                Log.d("DirectionsActivity", "Error: " + throwable.getMessage());
            }
        });
    }

    private void buyAdFree() {
        billingProcessor.purchase(this, PRODUCT_ID);
    }

    private void drawOptimizedRoute(DirectionsRoute route) {
        // Remove old polyline
        if (optimizedPolyline != null) {
            mapboxMap.removePolyline(optimizedPolyline);
        }
        // Draw points on MapView
        LatLng[] pointsToDraw = convertLineStringToLatLng(route);
        optimizedPolyline = mapboxMap.addPolyline(new PolylineOptions()
                .add(pointsToDraw)
                .color(Color.parseColor(WHITE_COLOR))
                .width(POLYLINE_WIDTH));
    }

    private LatLng[] convertLineStringToLatLng(DirectionsRoute route) {
        // Convert LineString coordinates into LatLng[]
        LineString lineString = LineString.fromPolyline(route.getGeometry(), PRECISION_6);
        List<Point> coordinates = lineString.coordinates();
        LatLng[] points = new LatLng[coordinates.size()];
        for (int i = 0; i < coordinates.size(); i++) {
            points[i] = new LatLng(
                    coordinates.get(i).latitude(),
                    coordinates.get(i).longitude());
        }
        return points;
    }

    @Override
    public void onStart() {
        super.onStart();

        mapView.onStart();
    }

    @Override
    public void onResume() {
        super.onResume();

        mapView.onResume();

        if (billingProcessor.isPurchased(PRODUCT_ID)) {
            hideAd();
        } else {
            showAd();
        }
    }

    @Override
    public void onPause() {
        super.onPause();

        mapView.onPause();
    }

    @Override
    public void onStop() {
        super.onStop();

        mapView.onStop();
    }

    @Override
    public void onLowMemory() {
        super.onLowMemory();

        mapView.onLowMemory();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();

        if (mapView != null) {
            mapView.onDestroy();
        }

        // Cancel the directions API request
        if (optimizedClient != null) {
            optimizedClient.cancelCall();
        }

        // End the navigation session
        if (mapboxNavigation != null) {
            mapboxNavigation.stopNavigation();
            mapboxNavigation.onDestroy();
        }

        if (billingProcessor != null) {
            billingProcessor.release();
        }
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {

        if (!billingProcessor.handleActivityResult(requestCode, resultCode, data)) {
            super.onActivityResult(requestCode, resultCode, data);
        }
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);

        mapView.onSaveInstanceState(outState);
    }

    private void showAd() {
        readyToPurchase = true;
        Appodeal.setInterstitialCallbacks(new InterstitialCallbacks() {
            @Override
            public void onInterstitialLoaded(boolean isPrecache) {
                Log.d("Appodeal", "onInterstitialLoaded");
                Appodeal.show(MapActivity.this, Appodeal.INTERSTITIAL);
            }
            @Override
            public void onInterstitialFailedToLoad() {
                Log.d("Appodeal", "onInterstitialFailedToLoad");
            }
            @Override
            public void onInterstitialShown() {
                Log.d("Appodeal", "onInterstitialShown");
            }
            @Override
            public void onInterstitialClicked() {
                Log.d("Appodeal", "onInterstitialClicked");
            }
            @Override
            public void onInterstitialClosed() {
                Log.d("Appodeal", "onInterstitialClosed");
            }
            @Override
            public void onInterstitialExpired() {
                Log.d("Appodeal", "onInterstitialExpired");
            }
        });
    }

    private void hideAd() {
        readyToPurchase = false;
    }
}