/*
 * Copyright 2000-2020 JetBrains s.r.o.
 *
 * 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 jetbrains.teamcity.ui.actions;

import jetbrains.buildServer.StateChangedEvent;
import jetbrains.buildServer.StateChangedListener;
import jetbrains.buildServer.TeamCityState;
import jetbrains.buildServer.TeamServerSummaryProvider;
import jetbrains.teamcity.Activator;
import jetbrains.teamcity.NotificationDispatcher;
import jetbrains.teamcity.core.TeamCityIDEAdapter;
import jetbrains.teamcity.ui.LoginAction;
import org.eclipse.core.runtime.Assert;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IMenuCreator;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.swt.events.HelpListener;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.jetbrains.annotations.NotNull;

public class AuthorizationActionWarpper implements IAction {

    public void addPropertyChangeListener(IPropertyChangeListener listener) {
        myDelegate.addPropertyChangeListener(listener);
    }

    public int getAccelerator() {
        return myDelegate.getAccelerator();
    }

    public String getActionDefinitionId() {
        return myDelegate.getActionDefinitionId();
    }

    public String getDescription() {
        return myDelegate.getDescription();
    }

    public ImageDescriptor getDisabledImageDescriptor() {
        return myDelegate.getDisabledImageDescriptor();
    }

    public HelpListener getHelpListener() {
        return myDelegate.getHelpListener();
    }

    public ImageDescriptor getHoverImageDescriptor() {
        return myDelegate.getHoverImageDescriptor();
    }

    public String getId() {
        return myDelegate.getId();
    }

    public ImageDescriptor getImageDescriptor() {
        return myDelegate.getImageDescriptor();
    }

    public IMenuCreator getMenuCreator() {
        return myDelegate.getMenuCreator();
    }

    public int getStyle() {
        return myDelegate.getStyle();
    }

    public String getText() {
        return myDelegate.getText();
    }

    public String getToolTipText() {
        return myDelegate.getToolTipText();
    }

    public boolean isChecked() {
        return myDelegate.isChecked();
    }

    public boolean isEnabled() {
        return myDelegate.isEnabled();
    }

    public boolean isHandled() {
        return myDelegate.isHandled();
    }

    public void removePropertyChangeListener(IPropertyChangeListener listener) {
        myDelegate.removePropertyChangeListener(listener);
    }

    private final LoginAction myLoginAction = new LoginAction();

    public void run() {
        final TeamCityState state = Activator.getDefault().getSnapshot().getState();
        if (TeamCityState.LOGGING_IN != state && TeamCityState.LOGGED_IN != state) {
            /**
             * disable delegate till wrapper is working...
             */
            myDelegate.setEnabled(false);
            //            final boolean enabled = myDelegate.isEnabled();
            /**
             * run Login Action and wait for success
             */
            final TeamCityIDEAdapter summaryListener = new TeamCityIDEAdapter() {
                
                @Override
                public boolean isActive(){
                    return true;
                }
                
                @Override
                public void updateSummary(@NotNull TeamServerSummaryProvider summaryProvider) {
                    if (summaryProvider.isSummaryAvailable()) {
                        Activator.getDefault().getNotificationDispatcher().removeListener(this);
                        myDelegate.setEnabled(true);
                        Display.getDefault().asyncExec(new Runnable() {
                            public void run() {
                                myDelegate.run();
                            }
                        });
                    }
                }
            };
            final StateChangedListener stateListener = new StateChangedListener() {
                public void stateChanged(@NotNull StateChangedEvent event) {
                    if (TeamCityState.LOGGED_IN == event.getNewState()) {
                        Activator.getDefault().getIDE().removeListener(this);
                        Activator.getDefault().getNotificationDispatcher().addListener(summaryListener, NotificationDispatcher.Scope.ALL);

                    } else if (TeamCityState.LOGGED_OUT_BY_USER == event.getNewState()) {
                        Activator.getDefault().getIDE().removeListener(this);

                    }
                }
            };
            Activator.getDefault().getIDE().addListener(stateListener);
            // do not allow to fire login over logging process
            myLoginAction.run();
        } else {
            myDelegate.run();
        }
    }

    public void runWithEvent(final Event event) {
        run();
    }

    public void setAccelerator(int keycode) {
        myDelegate.setAccelerator(keycode);
    }

    public void setActionDefinitionId(String id) {
        myDelegate.setActionDefinitionId(id);
    }

    public void setChecked(boolean checked) {
        myDelegate.setChecked(checked);
    }

    public void setDescription(String text) {
        myDelegate.setDescription(text);
    }

    public void setDisabledImageDescriptor(ImageDescriptor newImage) {
        myDelegate.setDisabledImageDescriptor(newImage);
    }

    public void setEnabled(boolean enabled) {
        myDelegate.setEnabled(enabled);
    }

    public void setHelpListener(HelpListener listener) {
        myDelegate.setHelpListener(listener);
    }

    public void setHoverImageDescriptor(ImageDescriptor newImage) {
        myDelegate.setHoverImageDescriptor(newImage);
    }

    public void setId(String id) {
        myDelegate.setId(id);
    }

    public void setImageDescriptor(ImageDescriptor newImage) {
        myDelegate.setImageDescriptor(newImage);
    }

    public void setMenuCreator(IMenuCreator creator) {
        myDelegate.setMenuCreator(creator);
    }

    public void setText(String text) {
        myDelegate.setText(text);
    }

    public void setToolTipText(String text) {
        myDelegate.setToolTipText(text);
    }

    private final IAction myDelegate;

    public AuthorizationActionWarpper(final IAction delegate) {
        Assert.isNotNull(delegate);
        myDelegate = delegate;
    }

}