/*
 * Copyright (C) 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.testingcamera2;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Set;

import android.content.Context;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.Surface;
import android.view.View;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemSelectedListener;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.CompoundButton;
import android.widget.Spinner;
import android.widget.TextView;
import android.widget.ToggleButton;
import android.hardware.camera2.CameraAccessException;
import android.hardware.camera2.CameraCaptureSession;
import android.hardware.camera2.CameraCaptureSession.CaptureCallback;
import android.hardware.camera2.CameraCharacteristics;
import android.hardware.camera2.CameraDevice;
import android.hardware.camera2.CameraManager;
import android.hardware.camera2.CaptureRequest;
import android.hardware.camera2.CaptureResult;
import android.hardware.camera2.CaptureFailure;
import android.hardware.camera2.TotalCaptureResult;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;

import com.android.testingcamera2.PaneTracker.PaneEvent;

import java.io.IOException;

/**
 *
 * Basic control pane block for the control list
 *
 */
public class CameraControlPane extends ControlPane {

    // XML attributes

    /** Name of pane tag */
    private static final String PANE_NAME = "camera_pane";

    /** Attribute: ID for pane (integer) */
    private static final String PANE_ID = "id";
    /** Attribute: ID for camera to select (String) */
    private static final String CAMERA_ID = "camera_id";

    // End XML attributes

    private static final int MAX_CACHED_RESULTS = 100;

    private static int mCameraPaneIdCounter = 0;

    /**
     * These correspond to the callbacks from
     * android.hardware.camera2.CameraDevice.StateCallback, plus UNAVAILABLE for
     * when there's not a valid camera selected.
     */
    private enum CameraState {
        UNAVAILABLE,
        CLOSED,
        OPENED,
        DISCONNECTED,
        ERROR
    }

    /**
     * These correspond to the callbacks from {@link CameraCaptureSession.StateCallback}, plus
     * {@code CONFIGURING} for before a session is returned and {@code NONE} for when there
     * is no session created.
     */
    private enum SessionState {
        NONE,
        CONFIGURED,
        CONFIGURE_FAILED,
        READY,
        ACTIVE,
        CLOSED
    }

    private enum CameraCall {
        NONE,
        CONFIGURE
    }

    private final int mPaneId;

    private CameraOps2 mCameraOps;
    private InfoDisplayer mInfoDisplayer;

    private Spinner mCameraSpinner;
    private ToggleButton mOpenButton;
    private Button mInfoButton;
    private TextView mStatusText;
    private Button mConfigureButton;
    private Button mStopButton;
    private Button mFlushButton;

    /**
     * All controls that should be enabled when there's a valid camera ID
     * selected
     */
    private final Set<View> mBaseControls = new HashSet<View>();
    /**
     * All controls that should be enabled when camera is at least in the OPEN
     * state
     */
    private final Set<View> mOpenControls = new HashSet<View>();
    /**
     * All controls that should be enabled when camera is at least in the IDLE
     * state
     */
    private final Set<View> mConfiguredControls = new HashSet<View>();

    private String[] mCameraIds;
    private String mCurrentCameraId;

    private CameraState mCameraState;
    private CameraDevice mCurrentCamera;
    private CameraCaptureSession mCurrentCaptureSession;
    private SessionState mSessionState = SessionState.NONE;
    private CameraCall mActiveCameraCall;
    private LinkedList<TotalCaptureResult> mRecentResults = new LinkedList<>();

    private List<Surface> mConfiguredSurfaces;
    private List<TargetControlPane> mConfiguredTargetPanes;

    /**
     * Constructor for tooling only
     */
    public CameraControlPane(Context context, AttributeSet attrs) {
        super(context, attrs, null, null);

        mPaneId = 0;
        setUpUI(context);
    }

    public CameraControlPane(TestingCamera21 tc, AttributeSet attrs, StatusListener listener) {

        super(tc, attrs, listener, tc.getPaneTracker());

        mPaneId = mCameraPaneIdCounter++;
        setUpUI(tc);
        initializeCameras(tc);

        if (mCameraIds != null) {
            switchToCamera(mCameraIds[0]);
        }
    }

    public CameraControlPane(TestingCamera21 tc, XmlPullParser configParser, StatusListener listener)
            throws XmlPullParserException, IOException {
        super(tc, null, listener, tc.getPaneTracker());

        configParser.require(XmlPullParser.START_TAG, XmlPullParser.NO_NAMESPACE, PANE_NAME);

        int paneId = getAttributeInt(configParser, PANE_ID, -1);
        if (paneId == -1) {
            mPaneId = mCameraPaneIdCounter++;
        } else {
            mPaneId = paneId;
            if (mPaneId >= mCameraPaneIdCounter) {
                mCameraPaneIdCounter = mPaneId + 1;
            }
        }

        String cameraId = getAttributeString(configParser, CAMERA_ID, null);

        configParser.next();
        configParser.require(XmlPullParser.END_TAG, XmlPullParser.NO_NAMESPACE, PANE_NAME);

        setUpUI(tc);
        initializeCameras(tc);

        boolean gotCamera = false;
        if (mCameraIds != null && cameraId != null) {
            for (int i = 0; i < mCameraIds.length; i++) {
                if (cameraId.equals(mCameraIds[i])) {
                    switchToCamera(mCameraIds[i]);
                    mCameraSpinner.setSelection(i);
                    gotCamera = true;
                }
            }
        }

        if (!gotCamera && mCameraIds != null) {
            switchToCamera(mCameraIds[0]);
        }
    }

    @Override
    public void remove() {
        closeCurrentCamera();
        super.remove();
    }

    /**
     * Get list of target panes that are currently actively configured for this
     * camera
     */
    public List<TargetControlPane> getCurrentConfiguredTargets() {
        return mConfiguredTargetPanes;
    }

    /**
     * Interface to be implemented by an application service for displaying a
     * camera's information.
     */
    public interface InfoDisplayer {
        public void showCameraInfo(String cameraId);
    }

    public CameraCharacteristics getCharacteristics() {
        if (mCurrentCameraId != null) {
            return mCameraOps.getCameraInfo(mCurrentCameraId);
        }
        return null;
    }

    public CaptureRequest.Builder getRequestBuilder(int template) {
        CaptureRequest.Builder request = null;
        if (mCurrentCamera != null) {
            try {
                request = mCurrentCamera.createCaptureRequest(template);
                // Workaround for b/15748139
                request.set(CaptureRequest.STATISTICS_LENS_SHADING_MAP_MODE,
                        CaptureRequest.STATISTICS_LENS_SHADING_MAP_MODE_ON);
            } catch (CameraAccessException e) {
                TLog.e("Unable to build request for camera %s with template %d.", e,
                        mCurrentCameraId, template);
            }
        }
        return request;
    }

    /**
     * Send single capture to camera device.
     *
     * @param request
     * @return true if capture sent successfully
     */
    public boolean capture(CaptureRequest request) {
        if (mCurrentCaptureSession != null) {
            try {
                mCurrentCaptureSession.capture(request, mResultListener, null);
                return true;
            } catch (CameraAccessException e) {
                TLog.e("Unable to capture for camera %s.", e, mCurrentCameraId);
            }
        }
        return false;
    }

    public boolean repeat(CaptureRequest request) {
        if (mCurrentCaptureSession != null) {
            try {
                mCurrentCaptureSession.setRepeatingRequest(request, mResultListener, null);
                return true;
            } catch (CameraAccessException e) {
                TLog.e("Unable to set repeating request for camera %s.", e, mCurrentCameraId);
            }
        }
        return false;
    }

    public TotalCaptureResult getResultAt(long timestamp) {
        for (TotalCaptureResult result : mRecentResults) {
            long resultTimestamp = result.get(CaptureResult.SENSOR_TIMESTAMP);
            if (resultTimestamp == timestamp) return result;
            if (resultTimestamp > timestamp) return null;
        }
        return null;
    }

    public void prepareSurface(Surface target) {
        if (mCurrentCaptureSession != null) {
            try {
                TLog.i("Preparing Surface " + target);
                mCurrentCaptureSession.prepare(target);
            } catch (CameraAccessException e) {
                TLog.e("Unable to prepare surface for camera %s.", e, mCurrentCameraId);
            } catch (IllegalArgumentException e) {
                TLog.e("Bad Surface passed to prepare", e);
            }
        }
    }

    private CaptureCallback mResultListener = new CaptureCallback() {
        @Override
        public void onCaptureStarted(CameraCaptureSession session,
                CaptureRequest request, long timestamp, long frameNumber) {
        }

        @Override
        public void onCaptureProgressed(CameraCaptureSession session,
                CaptureRequest request, CaptureResult partialResult) {
        }

        @Override
        public void onCaptureCompleted(
                CameraCaptureSession session,
                CaptureRequest request,
                TotalCaptureResult result) {
            mRecentResults.add(result);
            if (mRecentResults.size() > MAX_CACHED_RESULTS) {
                mRecentResults.remove();
            }
        }

        @Override
        public void onCaptureFailed(CameraCaptureSession session,
                CaptureRequest request, CaptureFailure failure) {
            TLog.e("Capture failed for request " + request +
                    " on frame  " + failure.getFrameNumber() + ": Reason " + failure.getReason() +
                    ". Images captured: " + failure.wasImageCaptured());
        }

        @Override
        public void onCaptureSequenceCompleted(CameraCaptureSession session,
                int sequenceId, long frameNumber) {
        }

        @Override
        public void onCaptureSequenceAborted(CameraCaptureSession session,
                int sequenceId) {
        }

        @Override
        public void onCaptureBufferLost(CameraCaptureSession session,
                CaptureRequest request, Surface target, long frameNumber) {
            TLog.e("Lost buffer for Surface " + target + " for request " + request +
                    " on frame " + frameNumber);
        }

    };

    private void setUpUI(Context context) {
        String paneName =
                String.format(Locale.US, "%s %c",
                        context.getResources().getString(R.string.camera_pane_title),
                        (char) ('A' + mPaneId));
        this.setName(paneName);

        LayoutInflater inflater =
                (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);

        inflater.inflate(R.layout.camera_pane, this);

        mCameraSpinner = (Spinner) findViewById(R.id.camera_pane_camera_spinner);
        mCameraSpinner.setOnItemSelectedListener(mCameraSpinnerListener);

        mOpenButton = (ToggleButton) findViewById(R.id.camera_pane_open_button);
        mOpenButton.setOnCheckedChangeListener(mOpenButtonListener);
        mBaseControls.add(mOpenButton);

        mInfoButton = (Button) findViewById(R.id.camera_pane_info_button);
        mInfoButton.setOnClickListener(mInfoButtonListener);
        mBaseControls.add(mInfoButton);

        mStatusText = (TextView) findViewById(R.id.camera_pane_status_text);

        mConfigureButton = (Button) findViewById(R.id.camera_pane_configure_button);
        mConfigureButton.setOnClickListener(mConfigureButtonListener);
        mOpenControls.add(mConfigureButton);

        mStopButton = (Button) findViewById(R.id.camera_pane_stop_button);
        mStopButton.setOnClickListener(mStopButtonListener);
        mConfiguredControls.add(mStopButton);
        mFlushButton = (Button) findViewById(R.id.camera_pane_flush_button);
        mFlushButton.setOnClickListener(mFlushButtonListener);
        mConfiguredControls.add(mFlushButton);
    }

    private void initializeCameras(TestingCamera21 tc) {
        mCameraOps = tc.getCameraOps();
        mInfoDisplayer = tc;

        updateCameraList();
    }

    private void updateCameraList() {
        mCameraIds = null;
        try {
            mCameraIds = mCameraOps.getCamerasAndListen(mCameraAvailabilityCallback);
            String[] cameraSpinnerItems = new String[mCameraIds.length];
            for (int i = 0; i < mCameraIds.length; i++) {
                cameraSpinnerItems[i] = String.format("Camera %s", mCameraIds[i]);
            }
            mCameraSpinner.setAdapter(new ArrayAdapter<String>(getContext(), R.layout.spinner_item,
                    cameraSpinnerItems));

        } catch (CameraAccessException e) {
            TLog.e("Exception trying to get list of cameras: " + e);
        }
    }

    private final CompoundButton.OnCheckedChangeListener mOpenButtonListener =
            new CompoundButton.OnCheckedChangeListener() {
                @Override
                public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
                    if (isChecked) {
                        // Open camera
                        mCurrentCamera = null;
                        mCameraOps.openCamera(mCurrentCameraId, mCameraListener);
                    } else {
                        // Close camera
                        closeCurrentCamera();
                    }
                }
            };

    private final OnClickListener mInfoButtonListener = new OnClickListener() {
        @Override
        public void onClick(View v) {
            mInfoDisplayer.showCameraInfo(mCurrentCameraId);
        }
    };

    private final OnClickListener mStopButtonListener = new OnClickListener() {
        @Override
        public void onClick(View v) {
            if (mCurrentCaptureSession != null) {
                try {
                    mCurrentCaptureSession.stopRepeating();
                } catch (CameraAccessException e) {
                    TLog.e("Unable to stop repeating request for camera %s.", e, mCurrentCameraId);
                }
            }
        }
    };

    private final OnClickListener mFlushButtonListener = new OnClickListener() {
        @Override
        public void onClick(View v) {
            if (mCurrentCaptureSession != null) {
                try {
                    mCurrentCaptureSession.abortCaptures();
                } catch (CameraAccessException e) {
                    TLog.e("Unable to flush camera %s.", e, mCurrentCameraId);
                }
            }
        }
    };

    private final OnClickListener mConfigureButtonListener = new OnClickListener() {
        @Override
        public void onClick(View v) {
            List<Surface> targetSurfaces = new ArrayList<Surface>();
            List<TargetControlPane> targetPanes = new ArrayList<TargetControlPane>();
            for (TargetControlPane targetPane : mPaneTracker.getPanes(TargetControlPane.class)) {
                Surface target = targetPane.getTargetSurfaceForCameraPane(getPaneName());
                if (target != null) {
                    targetSurfaces.add(target);
                    targetPanes.add(targetPane);
                }
            }
            try {
                TLog.i("Configuring camera %s with %d surfaces", mCurrentCamera.getId(),
                        targetSurfaces.size());
                mActiveCameraCall = CameraCall.CONFIGURE;
                if (targetSurfaces.size() > 0) {
                    mCurrentCamera.createCaptureSession(targetSurfaces, mSessionListener, /*handler*/null);
                } else if (mCurrentCaptureSession != null) {
                    mCurrentCaptureSession.close();
                    mCurrentCaptureSession = null;
                }
                mConfiguredSurfaces = targetSurfaces;
                mConfiguredTargetPanes = targetPanes;
            } catch (CameraAccessException e) {
                mActiveCameraCall = CameraCall.NONE;
                TLog.e("Unable to configure camera %s.", e, mCurrentCamera.getId());
            } catch (IllegalArgumentException e) {
                mActiveCameraCall = CameraCall.NONE;
                TLog.e("Unable to configure camera %s.", e, mCurrentCamera.getId());
            } catch (IllegalStateException e) {
                mActiveCameraCall = CameraCall.NONE;
                TLog.e("Unable to configure camera %s.", e, mCurrentCamera.getId());
            }
        }
    };

    private final CameraCaptureSession.StateCallback mSessionListener =
            new CameraCaptureSession.StateCallback() {

        @Override
        public void onConfigured(CameraCaptureSession session) {
            mCurrentCaptureSession = session;
            TLog.i("Configuration completed for camera %s.", mCurrentCamera.getId());

            setSessionState(SessionState.CONFIGURED);
        }

        @Override
        public void onConfigureFailed(CameraCaptureSession session) {
            mActiveCameraCall = CameraCall.NONE;
            TLog.e("Configuration failed for camera %s.", mCurrentCamera.getId());

            setSessionState(SessionState.CONFIGURE_FAILED);
        }

        @Override
        public void onReady(CameraCaptureSession session) {
            setSessionState(SessionState.READY);
        }

        /**
         * This method is called when the session starts actively processing capture requests.
         *
         * <p>If capture requests are submitted prior to {@link #onConfigured} being called,
         * then the session will start processing those requests immediately after the callback,
         * and this method will be immediately called after {@link #onConfigured}.
         *
         * <p>If the session runs out of capture requests to process and calls {@link #onReady},
         * then this callback will be invoked again once new requests are submitted for capture.</p>
         */
        @Override
        public void onActive(CameraCaptureSession session) {
            setSessionState(SessionState.ACTIVE);
        }

        /**
         * This method is called when the session is closed.
         *
         * <p>A session is closed when a new session is created by the parent camera device,
         * or when the parent camera device is closed (either by the user closing the device,
         * or due to a camera device disconnection or fatal error).</p>
         *
         * <p>Once a session is closed, all methods on it will throw an IllegalStateException, and
         * any repeating requests or bursts are stopped (as if {@link #stopRepeating()} was called).
         * However, any in-progress capture requests submitted to the session will be completed
         * as normal.</p>
         */
        @Override
        public void onClosed(CameraCaptureSession session) {
            // Ignore closes if the session has been replaced
            if (mCurrentCaptureSession != null && session != mCurrentCaptureSession) {
                return;
            }
            setSessionState(SessionState.CLOSED);
        }

        @Override
        public void onSurfacePrepared(CameraCaptureSession session, Surface surface) {
            TLog.i("Surface preparation complete for Surface " + surface);
        }

    };

    private final CameraDevice.StateCallback mCameraListener = new CameraDevice.StateCallback() {
        @Override
        public void onClosed(CameraDevice camera) {
            // Don't change state on close, tracked by callers of close()
            mOpenButton.setChecked(false);
        }

        @Override
        public void onDisconnected(CameraDevice camera) {
            setCameraState(CameraState.DISCONNECTED);
        }

        @Override
        public void onError(CameraDevice camera, int error) {
            setCameraState(CameraState.ERROR);
        }

        @Override
        public void onOpened(CameraDevice camera) {
            mCurrentCamera = camera;
            setCameraState(CameraState.OPENED);
        }
    };

    private void switchToCamera(String newCameraId) {
        closeCurrentCamera();

        mCurrentCameraId = newCameraId;

        if (mCurrentCameraId == null) {
            setCameraState(CameraState.UNAVAILABLE);
        } else {
            setCameraState(CameraState.CLOSED);
        }

        mPaneTracker.notifyOtherPanes(this, PaneTracker.PaneEvent.NEW_CAMERA_SELECTED);
    }

    private void closeCurrentCamera() {
        if (mCurrentCamera != null) {
            mCurrentCamera.close();
            mCurrentCamera = null;
            setCameraState(CameraState.CLOSED);
        }
    }

    private void setSessionState(SessionState newState) {
        mSessionState = newState;
        mStatusText.setText("S." + mSessionState.toString());

        switch (mSessionState) {
            case CONFIGURE_FAILED:
                mActiveCameraCall = CameraCall.NONE;
                // fall-through
            case CLOSED:
                enableBaseControls(true);
                enableOpenControls(true);
                enableConfiguredControls(false);
                mConfiguredTargetPanes = null;
                break;
            case NONE:
                enableBaseControls(true);
                enableOpenControls(true);
                enableConfiguredControls(false);
                mConfiguredTargetPanes = null;
                break;
            case CONFIGURED:
                if (mActiveCameraCall != CameraCall.CONFIGURE) {
                    throw new AssertionError();
                }
                mPaneTracker.notifyOtherPanes(this, PaneEvent.CAMERA_CONFIGURED);
                mActiveCameraCall = CameraCall.NONE;
                // fall-through
            case READY:
            case ACTIVE:
                enableBaseControls(true);
                enableOpenControls(true);
                enableConfiguredControls(true);
                break;
            default:
                throw new AssertionError("Unhandled case " + mSessionState);
        }
    }

    private void setCameraState(CameraState newState) {
        mCameraState = newState;
        mStatusText.setText("C." + mCameraState.toString());
        switch (mCameraState) {
            case UNAVAILABLE:
                enableBaseControls(false);
                enableOpenControls(false);
                enableConfiguredControls(false);
                mConfiguredTargetPanes = null;
                break;
            case CLOSED:
            case DISCONNECTED:
            case ERROR:
                enableBaseControls(true);
                enableOpenControls(false);
                enableConfiguredControls(false);
                mConfiguredTargetPanes = null;
                break;
            case OPENED:
                enableBaseControls(true);
                enableOpenControls(true);
                enableConfiguredControls(false);
                mConfiguredTargetPanes = null;
                break;
        }
    }

    private void enableBaseControls(boolean enabled) {
        for (View v : mBaseControls) {
            v.setEnabled(enabled);
        }
        if (!enabled) {
            mOpenButton.setChecked(false);
        }
    }

    private void enableOpenControls(boolean enabled) {
        for (View v : mOpenControls) {
            v.setEnabled(enabled);
        }
    }

    private void enableConfiguredControls(boolean enabled) {
        for (View v : mConfiguredControls) {
            v.setEnabled(enabled);
        }
    }

    private final CameraManager.AvailabilityCallback mCameraAvailabilityCallback =
            new CameraManager.AvailabilityCallback() {
        @Override
        public void onCameraAvailable(String cameraId) {
            // TODO: Update camera list in an intelligent fashion
            // (can't just call updateCameraList or the selected camera may change)
        }

        @Override
        public void onCameraUnavailable(String cameraId) {
            // TODO: Update camera list in an intelligent fashion
            // (can't just call updateCameraList or the selected camera may change)
        }
    };

    private final OnItemSelectedListener mCameraSpinnerListener = new OnItemSelectedListener() {
        @Override
        public void onItemSelected(AdapterView<?> parent, View view, int pos, long id) {
            String newCameraId = mCameraIds[pos];
            if (newCameraId != mCurrentCameraId) {
                switchToCamera(newCameraId);
            }
        }

        @Override
        public void onNothingSelected(AdapterView<?> parent) {
            switchToCamera(null);
        }
    };
}