/*
 * Copyright (C) 2011 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.camera.ui;

import com.android.camera.CameraPreference.OnPreferenceChangedListener;
import com.android.camera.PreferenceGroup;
import com.android.camera.R;
import com.android.camera.Util;

import android.content.Context;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;

/**
 * On the tablet UI, we have IndicatorControlWheelContainer which contains a
 * ShutterButton, a IndicatorControlWheel (which combines first-level and
 * second-level indicators) and a ZoomControlWheel.
 */
public class IndicatorControlWheelContainer extends IndicatorControlContainer {
    public static final int STROKE_WIDTH = 87;
    public static final int SHUTTER_BUTTON_RADIUS = 74;
    public static final int FULL_WHEEL_RADIUS = 93;

    private static final String TAG = "IndicatorControlWheelContainer";

    private View mShutterButton;
    private double mShutterButtonRadius;
    private IndicatorControlWheel mIndicatorControlWheel;
    private ZoomControlWheel mZoomControlWheel;
    private int mCenterX, mCenterY;

    public IndicatorControlWheelContainer(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    @Override
    protected void onFinishInflate() {
        mShutterButton = findViewById(R.id.shutter_button);
        mShutterButtonRadius = Util.dpToPixel(SHUTTER_BUTTON_RADIUS);

        mZoomControlWheel = (ZoomControlWheel) findViewById(R.id.zoom_control);
        mZoomControlWheel.setOnIndicatorEventListener(this);

        mIndicatorControlWheel = (IndicatorControlWheel) findViewById(
                R.id.indicator_control_wheel);
    }

    public void initialize(Context context, PreferenceGroup group,
            boolean isZoomSupported, String[] keys, String[] otherSettingKeys) {
        mIndicatorControlWheel.initialize(context, group, isZoomSupported,
                keys, otherSettingKeys);
        mIndicatorControlWheel.setOnIndicatorEventListener(this);
    }

    public void onIndicatorEvent(int event) {
        switch (event) {
            case OnIndicatorEventListener.EVENT_ENTER_ZOOM_CONTROL:
                mIndicatorControlWheel.setVisibility(View.GONE);
                mZoomControlWheel.setVisibility(View.VISIBLE);
                mZoomControlWheel.startZoomControl();
                break;

            case OnIndicatorEventListener.EVENT_LEAVE_ZOOM_CONTROL:
                mZoomControlWheel.setVisibility(View.GONE);
                mIndicatorControlWheel.setVisibility(View.VISIBLE);
                break;
        }
    }

    @Override
    public boolean dispatchTouchEvent(MotionEvent event) {
        if (!onFilterTouchEventForSecurity(event)) return false;

        int action = event.getAction();

        double dx = event.getX() - mCenterX;
        double dy = mCenterY - event.getY();
        double radius = Math.sqrt(dx * dx + dy * dy);

        // Check if the event should be dispatched to the shutter button.
        if (radius <= mShutterButtonRadius) {
            if (mIndicatorControlWheel.getVisibility() == View.VISIBLE) {
                mIndicatorControlWheel.onTouchOutBound();
            } else {
                return mZoomControlWheel.dispatchTouchEvent(event);
            }
            if (action == MotionEvent.ACTION_DOWN || action == MotionEvent.ACTION_UP) {
                return mShutterButton.dispatchTouchEvent(event);
            }
            return false;
        }

        if (mShutterButton.isPressed()) {
            // Send cancel to the shutter button if it was pressed.
            event.setAction(MotionEvent.ACTION_CANCEL);
            mShutterButton.dispatchTouchEvent(event);
            return true;
        }

        if (mIndicatorControlWheel.getVisibility() == View.VISIBLE) {
            return mIndicatorControlWheel.dispatchTouchEvent(event);
        } else {
            return mZoomControlWheel.dispatchTouchEvent(event);
        }
    }

    @Override
    protected void onLayout(
            boolean changed, int left, int top, int right, int bottom) {

        // Layout the shutter button.
        int shutterButtonWidth = mShutterButton.getMeasuredWidth();
        int shutterButtonHeight = mShutterButton.getMeasuredHeight();
        mCenterX = right - left - Util.dpToPixel(FULL_WHEEL_RADIUS);
        mCenterY = (bottom - top) / 2;
        mShutterButton.layout(right - left - shutterButtonWidth,
                mCenterY - shutterButtonHeight / 2,
                right - left,
                mCenterY + shutterButtonHeight - shutterButtonHeight / 2);
        // Layout the control wheel.
        mIndicatorControlWheel.layout(0, 0, right - left, bottom - top);
        mZoomControlWheel.layout(0, 0, right - left, bottom - top);
    }

    @Override
    protected void onMeasure(int widthSpec, int heightSpec) {
        // Measure all children.
        int freeSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
        mShutterButton.measure(freeSpec, freeSpec);
        mIndicatorControlWheel.measure(freeSpec, freeSpec);
        mZoomControlWheel.measure(freeSpec, freeSpec);

        // Measure myself. Add some buffer for highlight arc.
        int desiredWidth = mShutterButton.getMeasuredWidth()
                + IndicatorControlWheel.HIGHLIGHT_WIDTH * 4;
        int desiredHeight = mShutterButton.getMeasuredHeight()
                + IndicatorControlWheel.HIGHLIGHT_WIDTH * 4;
        int widthMode = MeasureSpec.getMode(widthSpec);
        int heightMode = MeasureSpec.getMode(heightSpec);
        int measuredWidth, measuredHeight;
        if (widthMode == MeasureSpec.UNSPECIFIED) {
            measuredWidth = desiredWidth;
        } else if (widthMode == MeasureSpec.AT_MOST) {
            measuredWidth = Math.min(desiredWidth, MeasureSpec.getSize(widthSpec));
        } else {  // MeasureSpec.EXACTLY
            measuredWidth = MeasureSpec.getSize(widthSpec);
        }
        if (heightMode == MeasureSpec.UNSPECIFIED) {
            measuredHeight = desiredHeight;
        } else if (heightMode == MeasureSpec.AT_MOST) {
            measuredHeight = Math.min(desiredHeight, MeasureSpec.getSize(heightSpec));
        } else {  // MeasureSpec.EXACTLY
            measuredHeight = MeasureSpec.getSize(heightSpec);
        }
        setMeasuredDimension(measuredWidth, measuredHeight);
    }

    @Override
    public void setListener(OnPreferenceChangedListener listener) {
        mIndicatorControlWheel.setListener(listener);
    }

    @Override
    public void reloadPreferences() {
        mIndicatorControlWheel.reloadPreferences();
    }

    @Override
    public View getActiveSettingPopup() {
        return mIndicatorControlWheel.getActiveSettingPopup();
    }

    @Override
    public boolean dismissSettingPopup() {
        return mIndicatorControlWheel.dismissSettingPopup();
    }

    @Override
    public void setOrientation(int orientation) {
        mIndicatorControlWheel.setOrientation(orientation);
        mZoomControlWheel.setOrientation(orientation);
    }

    public void startTimeLapseAnimation(int timeLapseInterval, long startTime) {
        mIndicatorControlWheel.startTimeLapseAnimation(
                timeLapseInterval, startTime);
    }

    public void stopTimeLapseAnimation() {
        mIndicatorControlWheel.stopTimeLapseAnimation();
    }

    @Override
    public void setEnabled(boolean enabled) {
        mIndicatorControlWheel.setEnabled(enabled);
        mZoomControlWheel.setEnabled(enabled);
    }

    @Override
    public void enableZoom(boolean enabled) {
        mIndicatorControlWheel.enableZoom(enabled);
    }

    @Override
    public void overrideSettings(final String ... keyvalues) {
        mIndicatorControlWheel.overrideSettings(keyvalues);
    }

    @Override
    public void dismissSecondLevelIndicator() {
        mIndicatorControlWheel.dismissSecondLevelIndicator();
    }
}