//This file has been modified by whb.

package dk.network42.osmfocus;

import android.Manifest;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.AlertDialog.Builder;
import android.app.Dialog;
import android.app.NotificationManager;
import android.content.ComponentCallbacks2;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.res.Configuration;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.location.GpsSatellite;
import android.location.GpsStatus;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.preference.PreferenceManager;
import android.support.v4.app.ActivityCompat;
import android.support.v4.app.DialogFragment;
import android.support.v4.app.NotificationCompat;
import android.support.v4.content.ContextCompat;
import android.support.v4.view.GestureDetectorCompat;
import android.util.Log;
import android.view.GestureDetector;
import android.view.Menu;
import android.view.MenuItem;
import android.view.MotionEvent;
import android.view.ScaleGestureDetector;
import android.view.WindowManager;
import android.widget.Toast;

import java.util.Iterator;
import java.util.List;

public class MainActivity extends Activity implements
        LocationListener, GpsStatus.Listener,
        SensorEventListener {

    public static final String userAgent = "OSMfocus";
    public static final String PREFS_NAME = "OSMFocusPrefsFile";
    static final int PREFERENCE_REQUEST = 9001;
    static final int PERMISSION_REQUEST_ACCESS_FINE_LOCATION = 9002;
    static final int INVALIDATE_VIEW = 1000;
    static final int POLL_NOTIFICATIONS = 1001;
    private static final int LOCATION_INTERVAL = 1000; //ms
    private static final float LOCATION_DISTANCE = 1f; //meters
    private static final String TAG = "OsmFocusActivity";
    public double mLonLastUpd = 0, mLatLastUpd = 0;  // Where mapview was last updated
    LocationManager mLocationManager;
    SensorManager sensorManager;
    double mPanLon, mPanLat;
    SharedData mG = null;
    NotificationManager mNotificationManager;
    Handler mHandler;
    private Sensor sensorAccelerometer;
    private Sensor sensorMagneticField;
    private float[] valuesAccelerometer;
    private float[] valuesMagneticField;
    private float[] matrixR;
    private float[] matrixI;
    private float[] matrixValues;
    private MapView mapView;
    private OsmServer mOsmServer = new OsmServer(null, userAgent);
    private GestureDetectorCompat mGestureDetector;
    private ScaleGestureDetector mScaleGestureDetector;
    private boolean mScaleInProgress = false;
    private final ScaleGestureDetector.OnScaleGestureListener mScaleGestureListener
            = new ScaleGestureDetector.SimpleOnScaleGestureListener() {
        @Override
        public boolean onScaleBegin(ScaleGestureDetector scaleGestureDetector) {
            float focusX = scaleGestureDetector.getFocusX();
            float focusY = scaleGestureDetector.getFocusY();
            Log.d(TAG, "ScaleBegin, focus=" + focusX + "," + focusY);
            return true;
        }

        @Override
        public boolean onScale(ScaleGestureDetector scaleGestureDetector) {
            float focusX = scaleGestureDetector.getFocusX();
            float focusY = scaleGestureDetector.getFocusY();
            float scale = scaleGestureDetector.getScaleFactor();
            Log.d(TAG, "Scale, scale=" + scale + ", focus=" + focusX + "," + focusY);
            mG.mPcfg.setScale(mG.mPcfg.getScale() * scale, mG.mCtx);
            mScaleInProgress = true;
            mapView.postInvalidate();
            return true;
        }

        @Override
        public void onScaleEnd(ScaleGestureDetector scaleGestureDetector) {
            Log.d(TAG, "ScaleEnd");
        }
    };
    private final GestureDetector.SimpleOnGestureListener mGestureListener
            = new GestureDetector.SimpleOnGestureListener() {
        @Override
        public boolean onDown(MotionEvent event) {
            //Log.d(TAG,"onDown: " + event.toString());
            mPanLon = mG.mLon;
            mPanLat = mG.mLat;
            mScaleInProgress = false;
            return true;
        }

        @Override
        public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX,
                                float distanceY) {
            if (mScaleInProgress) {
                Log.d(TAG, "Scroll skipped");
                return false;
            }
            //Log.d(TAG, "onScroll: " + e1.toString()+e2.toString());
            float dx, dy;
            dx = e2.getX() - e1.getX();
            dy = e2.getY() - e1.getY();
            Log.d(TAG, "Scroll pixels: x=" + dx + " y=" + dy);
            mG.mLon = mPanLon - dx / (mG.mPcfg.mScale * MapView.prescale);
            double panMercLat = dy / (mG.mPcfg.mScale * MapView.prescale);
            mG.mLat = GeoMath.mercatorToLat((GeoMath.latToMercator(mPanLat) + panMercLat));
            Log.d(TAG, "Scroll to lon=" + mG.mLon + " lat=" + mG.mLat + " (" + GeoMath.latToMercator(mPanLat) + "+" + panMercLat + ")");
            mG.mFollowGPS = false;
            mapView.postInvalidate();
            return true;
        }

        @Override
        public boolean onFling(MotionEvent event1, MotionEvent event2,
                               float velocityX, float velocityY) {
            Log.d(TAG, "onFling: " + event1.toString() + event2.toString());
            return true;
        }

//        @Override
//        public void onLongPress(MotionEvent event) {
//            Log.d(TAG, "onLongPress: " + event.toString());
//            openOptionsMenu();
//        }
        //@Override
        //public void onShowPress(MotionEvent event) {
        //    Log.d(TAG, "onShowPress: " + event.toString());
        //}

        //@Override
        //public boolean onSingleTapUp(MotionEvent event) {
        //    Log.d(TAG, "onSingleTapUp: " + event.toString());
        //    return true;
        // }
    };

    public static void showOkDialog(Context context, String txt) {
        Builder builder = new AlertDialog.Builder(context);
        builder.setMessage(txt);
        builder.setCancelable(true);
        builder.setPositiveButton("OK", null);
        AlertDialog dialog = builder.create();
        dialog.show();
    }

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

        SharedData.checkAppUpdate(getApplicationContext());
        PreferenceManager.setDefaultValues(this, R.xml.preferences, true);

        //setContentView(R.layout.activity_main);
        //getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
        //        WindowManager.LayoutParams.FLAG_FULLSCREEN);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON,
                WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
        //requestWindowFeature(Window.FEATURE_NO_TITLE);
        getActionBar().setDisplayShowTitleEnabled(false);

        Log.i(TAG, "API level " + Build.VERSION.SDK_INT);

        mHandler = new Handler(Looper.getMainLooper()) {
            int mNotifId;
            boolean mNotifActive;

            @Override
            public void handleMessage(Message inputMessage) {
                switch (inputMessage.what) {
                    case INVALIDATE_VIEW:
                        //Log.d(TAG, "Invalidate view");
                        mapView.invalidate();
                        // Fall-through
                    case POLL_NOTIFICATIONS:
                        int dlsb = mG.mTileLayerProvider.getActiveDownloads();
                        int dlsv = mG.mVectorLayerProvider.getActiveDownloads();
                        Log.d(TAG, "Downloads active=" + dlsb + "+" + dlsv);
                        if (dlsb > 0 || dlsv > 0) {
                            if (!mNotifActive) {
                                String st = "Downloading...";
                                mNotifId = setOsmLoadNotif(st);
                                mNotifActive = true;
                            } else {
                                Log.d(TAG, "Notification already active");
                                mHandler.sendMessageDelayed(mHandler.obtainMessage(POLL_NOTIFICATIONS, this), 1000);
                            }
                        } else if (mNotifActive) {
                            cancelOsmLoadNotif(mNotifId);
                            mNotifActive = false;
                        }
                        break;
                }
            }
        };

        mapView = new MapView(this);
        //mG.mPcfg.update(getBaseContext());
        setContentView(mapView);
        mapView.requestFocus();
        if (getLastNonConfigurationInstance() != null) {
            Log.d(TAG, "getLastNonConfigurationInstance() != null");
            mG = (SharedData) getLastNonConfigurationInstance();
            mapView.setSharedData(mG);
            mG.mTileLayer.setMainHandler(mHandler);
            mG.mVectorLayer.setMainHandler(mHandler);
            mG.update(getApplicationContext());
        } else {
            long maxMemL = Runtime.getRuntime().maxMemory();
            int maxMem = (int) Math.min(maxMemL, Integer.MAX_VALUE);
            Log.i(TAG, "maxMemory=" + maxMem);
            mG = new SharedData();
            mapView.setSharedData(mG);
            mG.mTileLayerProvider = new OsmTileProvider(mG.mOsmServerAgentName, OsmTile.MAX_DOWNLOAD_THREADS);
            mG.mTileLayer = new OsmTileLayerBm(mG.mTileLayerProvider, maxMem / 4);
            mG.mTileLayer.setAttrib(getApplicationContext().getString(R.string.info_osm_copyright));
            mG.mTileLayer.setMainHandler(mHandler);
            mG.mTileLayer.setProviderUrl(OsmTileLayer.urlFromType(mG.mPcfg.mBackMapType));
            mG.mVectorLayerProvider = new OsmTileProvider(mG.mOsmServerAgentName);
            mG.mVectorLayer = new OsmTileLayerVector(mG.mVectorLayerProvider, maxMem / 8);
            mG.mVectorLayer.setSharedData(mG);
            mG.mVectorLayer.setMainHandler(mHandler);
            mG.update(getApplicationContext());
        }

        if (mG.mDeveloperMode) {
            if (!(Thread.getDefaultUncaughtExceptionHandler() instanceof CustomExceptionHandler)) {
                Thread.setDefaultUncaughtExceptionHandler(new CustomExceptionHandler(mG, ""));
            }
        }

        mGestureDetector = new GestureDetectorCompat(this, mGestureListener);
        mScaleGestureDetector = new ScaleGestureDetector(this, mScaleGestureListener);
        /*mDetector.setOnDoubleTapListener(this);*/

        mNotificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);

        if (mG.mUseCompass) {
            sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
            sensorAccelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
            sensorMagneticField = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);
            valuesAccelerometer = new float[3];
            valuesMagneticField = new float[3];
            matrixR = new float[9];
            matrixI = new float[9];
            matrixValues = new float[3];
        }

        //registerForContextMenu(mapView);

        registerComponentCallbacks(new ComponentCallbacks2() {
            @Override
            public void onTrimMemory(int level) {
                appTrimMemory(level);
            }

            public void onLowMemory() {
                appTrimMemory(TRIM_MEMORY_COMPLETE);
            }

            public void onConfigurationChanged(Configuration newConfig) {
                //
            }
        });
    }

    public void appTrimMemory(int level) {
        Log.d(TAG, "appTrimMemory(" + level + ")");
        if (mG.mTileLayer != null)
            mG.mTileLayer.onTrimMemory(level);
        if (mG.mVectorLayer != null)
            mG.mVectorLayer.onTrimMemory(level);
    }

    public Object onRetainNonConfigurationInstance() {
        if (mG != null)
            return mG;
        return super.onRetainNonConfigurationInstance();
    }

    /*
     * Called when the Activity becomes visible.
     */
    @Override
    protected void onStart() {
        super.onStart();
    }

    /*
     * Called when the Activity is no longer visible.
     */
    @Override
    protected void onStop() {
        super.onStop();
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        switch (requestCode) {
            case PREFERENCE_REQUEST:
                mG.update(getBaseContext());
                mapView.postInvalidate();
                break;
        }
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        boolean h = mScaleGestureDetector.onTouchEvent(event);
        h |= mGestureDetector.onTouchEvent(event);
        h |= super.onTouchEvent(event);
        return h;
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.main_activity_actions, menu);
        if (mG.mDeveloperMode) {
            menu.add(0, R.id.action_testdownload, Menu.NONE, R.string.action_testdownload);
            menu.add(0, R.id.action_togglehud, Menu.NONE, R.string.action_togglehud);
        }
        return super.onCreateOptionsMenu(menu);
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        int itemId = item.getItemId();
        if (itemId == R.id.action_download) {
            if (mG.mPhyLocation != null) {
                Log.d(TAG, "Download");
                //float horizon = 250f; //meters
                //GeoBBox bbox = OsmServer.getBoxForPoint(mG.mLat, mG.mLon, horizon);
                //GeoBBox bbox = OsmTile.pos2BBox(mG.mLon, mG.mLat, 16);
                //downloadBox(bbox);
                // FIXME
                mG.mVectorLayer.download(mG.mLon, mG.mLat);
            } else {
                Toast toast = Toast.makeText(getApplicationContext(), getBaseContext().getString(R.string.info_locationunknown), Toast.LENGTH_SHORT);
                toast.show();
            }
            return true;
//		} else if (itemId == R.id.action_testdownload) {
//			Log.d(TAG, "Test Download");
//			float horizon = 250f; //meters
//			GeoBBox bbox = OsmServer.getBoxForPoint(mG.mLat, mG.mLon, horizon);
//			olddownloadBox(bbox);
//			return true;
//		} else if (itemId == R.id.action_loadcache) {
//			Log.d(TAG, "Load Cache");
//			readOSMFile("cache.osm");
//			return true;
        } else if (itemId == R.id.action_whereami) {
            Log.d(TAG, "Where am I?");
            mG.mFollowGPS = true;
            mG.mPcfg.setScale(PaintConfig.DEFAULT_ZOOM, mG.mCtx);
            if (mG.mPhyLocation != null) {
                mG.mLat = mG.mPhyLocation.getLatitude();
                mG.mLon = mG.mPhyLocation.getLongitude();
                mapView.postInvalidate();
            } else {
                Toast toast = Toast.makeText(getApplicationContext(), getBaseContext().getString(R.string.info_locationunknown), Toast.LENGTH_SHORT);
                toast.show();
            }
            return true;
        } else if (itemId == R.id.action_togglehud) {
            mG.mDebugHUD = !mG.mDebugHUD;
            mapView.invalidate();
            return true;
        } else if (itemId == R.id.action_settings) {
            startActivityForResult(new Intent(this, SettingsActivity.class), PREFERENCE_REQUEST);
            mG.update(getApplicationContext());
            return true;
        } else if (itemId == R.id.action_license) {
            startActivity(new Intent(this, LicenseActivity.class));
            mG.update(getApplicationContext());
            return true;
        } else {
            return super.onOptionsItemSelected(item);
        }
    }

    //@Override
    //public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
    //	super.onCreateContextMenu(menu, v, menuInfo);
    //    getMenuInflater().inflate(R.menu.main, menu);
    //}

    @Override
    protected void onResume() {
        super.onResume();
        //locationManager.requestLocationUpdates(mG.mLocProvider, 1000/*ms*/, 1/*meters*/, this);
        mLocationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
        checkAndRequestLocationUpdates();

        if (mG.mUseCompass) {
            sensorManager.registerListener(this,
                    sensorAccelerometer,
                    SensorManager.SENSOR_DELAY_NORMAL);
            sensorManager.registerListener(this,
                    sensorMagneticField,
                    SensorManager.SENSOR_DELAY_NORMAL);
        }
    }

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

        if (mLocationManager != null) {
            try {
                mLocationManager.removeUpdates(this);
            } catch (Exception e) {
                Log.e(TAG, "removeUpdates failed", e);
            }
        }

        if (mG.mUseCompass) {
            sensorManager.unregisterListener(this,
                    sensorAccelerometer);
            sensorManager.unregisterListener(this,
                    sensorMagneticField);
        }
    }

    protected Location getMostRecentKnownLocation() {
        Location loc = null;
        long besttime = 0;
        List<String> allp = mLocationManager.getAllProviders();
        for (String p : allp) {
            if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
                    == PackageManager.PERMISSION_GRANTED) {
                Location l = mLocationManager.getLastKnownLocation(p);
                if (l != null) {
                    long time = l.getTime();
                    if (time > besttime) {
                        loc = l;
                        besttime = time;
                    }
                }
            }
        }
        return loc;
    }

    private void checkAndRequestLocationUpdates() {
        if (mLocationManager != null) {
            if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
                    == PackageManager.PERMISSION_GRANTED) {
                mLocationManager.addGpsStatusListener(this);
            } else {
                if (ActivityCompat.shouldShowRequestPermissionRationale(this,
                        Manifest.permission.ACCESS_FINE_LOCATION)) {
                } else {
                    ActivityCompat.requestPermissions(this,
                            new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
                            PERMISSION_REQUEST_ACCESS_FINE_LOCATION);
                }
            }

            Location loc = getMostRecentKnownLocation();
            if (loc != null)
                this.onLocationChanged(loc);

            if (mLocationManager.isProviderEnabled(LocationManager.GPS_PROVIDER)) {
                if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
                        == PackageManager.PERMISSION_GRANTED) {
                    mLocationManager.requestLocationUpdates(
                            LocationManager.GPS_PROVIDER, LOCATION_INTERVAL, LOCATION_DISTANCE, this);
                }
            } else if (mLocationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER)) {
                if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION)
                        == PackageManager.PERMISSION_GRANTED) {
                    mLocationManager.requestLocationUpdates(
                            LocationManager.NETWORK_PROVIDER, LOCATION_INTERVAL, LOCATION_DISTANCE, this);
                }
            }
        }
    }

    @Override
    public void onRequestPermissionsResult(int request, String permissions[], int[] granted) {
        switch (request) {
            case PERMISSION_REQUEST_ACCESS_FINE_LOCATION: {
                if (granted.length > 0 && granted[0] == PackageManager.PERMISSION_GRANTED) {
                    Toast.makeText(this, "Location permission granted!", Toast.LENGTH_LONG).show();
                    checkAndRequestLocationUpdates();
                } else {
                    Toast.makeText(this, "Location permission denied!", Toast.LENGTH_LONG).show();
                }
                return;
            }
        }
    }

    @Override
    public void onLocationChanged(Location location) {
        mG.mPhyLocation = location;
        mG.mLocationUpdates++;
        double curr_lon = mG.mPhyLocation.getLongitude();
        double curr_lat = mG.mPhyLocation.getLatitude();
        if (mG.mFollowGPS) {
            mG.mLon = curr_lon;
            mG.mLat = curr_lat;
        }
        //Log.d(TAG, "onLocationChanged, Loc="+mG.mPhyLocation);
        final double noise = 0.00002;
        if (Math.abs(mLonLastUpd - curr_lon) > noise || Math.abs(mLatLastUpd - curr_lat) > noise) {
            mLonLastUpd = curr_lon;
            mLatLastUpd = curr_lat;
            mapView.postInvalidate();
        }
    }

    @Override
    public void onProviderDisabled(String provider) {
        //Log.e(TAG, "onProviderDisabled: " + provider);
    }

    @Override
    public void onProviderEnabled(String provider) {
        //Log.e(TAG, "onProviderEnabled: " + provider);
    }

    @Override
    public void onStatusChanged(String provider, int status, Bundle extras) {
        //Log.e(TAG, "onStatusChanged: " + provider);
    }

    public void onGpsStatusChanged(int event) {
        boolean statchg = false;
        switch (event) {
            case GpsStatus.GPS_EVENT_SATELLITE_STATUS:
                if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
                        == PackageManager.PERMISSION_GRANTED) {
                    GpsStatus gstat = mLocationManager.getGpsStatus(null);
                    if (gstat != null) {
                        Iterable<GpsSatellite> satellites = gstat.getSatellites();
                        Iterator<GpsSatellite> sat = satellites.iterator();
                        int num = 0, used = 0;
                        while (sat.hasNext()) {
                            num++;
                            GpsSatellite satellite = sat.next();
                            if (satellite.usedInFix()) {
                                used++;
                            }
                        }
                        if (mG.mSatelitesVisible != num || mG.mSatelitesUsed != used)
                            statchg = true;
                        mG.mSatelitesVisible = num;
                        mG.mSatelitesUsed = used;
                    }
                }
                break;
        }
        if (statchg)
            mapView.postInvalidate();
    }

    @Override
    public void onSensorChanged(SensorEvent event) {

        switch (event.sensor.getType()) {
            case Sensor.TYPE_ACCELEROMETER:
                for (int i = 0; i < 3; i++) {
                    valuesAccelerometer[i] = event.values[i];
                }
                break;
            case Sensor.TYPE_MAGNETIC_FIELD:
                for (int i = 0; i < 3; i++) {
                    valuesMagneticField[i] = event.values[i];
                }
                break;
        }

        boolean success = SensorManager.getRotationMatrix(
                matrixR,
                matrixI,
                valuesAccelerometer,
                valuesMagneticField);

        if (success) {
            SensorManager.getOrientation(matrixR, matrixValues);

            mG.mAzimuth = Math.toDegrees(matrixValues[0]);
            mG.mPitch = Math.toDegrees(matrixValues[1]);
            mG.mRoll = Math.toDegrees(matrixValues[2]);
            //Log.d(TAG, "Orientation: Azimuth " + azimuth + ", Pitch " + pitch + ", Roll " + roll);
            mapView.postInvalidate();

        }
    }

    int setOsmLoadNotif(String info) {
        int notifyID = 1;
        NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(/*this*/getApplicationContext())
                .setContentTitle("Downloading OSM Data")
                .setContentText(info)
                .setSmallIcon(R.drawable.ic_downloadosm);
//		Intent resultIntent = new Intent(/*this*/getApplicationContext(), MainActivity.class); //FIXME
//		PendingIntent resultPendingIntent =
//				PendingIntent.getActivity(
//						/*this*/getApplicationContext(),
//						0,
//						resultIntent,
//						PendingIntent.FLAG_UPDATE_CURRENT
//						);
//		mBuilder.setContentIntent(resultPendingIntent);
        mNotificationManager.notify(
                notifyID,
                mBuilder.build());
        Log.d(TAG, "Set OSM notif, id=" + notifyID);
        return notifyID;
    }

    void cancelOsmLoadNotif(int notifyID) {
        Log.d(TAG, "Clear OSM notif, id=" + notifyID);
        mNotificationManager.cancel(notifyID);
    }

    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {
    }

    // Define a DialogFragment that displays the error dialog
    public static class ErrorDialogFragment extends DialogFragment {
        // Global field to contain the error dialog
        private Dialog mDialog;

        // Default constructor. Sets the dialog field to null
        public ErrorDialogFragment() {
            super();
            mDialog = null;
        }

        // Set the dialog to display
        public void setDialog(Dialog dialog) {
            mDialog = dialog;
        }

        // Return a Dialog to the DialogFragment.
        @Override
        public Dialog onCreateDialog(Bundle savedInstanceState) {
            return mDialog;
        }
    }
}