// 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.googlesource.gerrit.plugins.xdocs.client;

import com.google.gerrit.client.rpc.NativeMap;
import com.google.gerrit.client.rpc.Natives;
import com.google.gerrit.plugin.client.Plugin;
import com.google.gwt.core.client.JsArray;
import com.google.gwt.resources.client.ImageResource;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.google.gwt.user.client.ui.AbstractImagePrototype;
import com.google.gwt.user.client.ui.FlexTable;
import com.google.gwt.user.client.ui.FlowPanel;
import com.google.gwt.user.client.ui.HorizontalPanel;
import com.google.gwt.user.client.ui.InlineHTML;
import com.google.gwt.user.client.ui.InlineHyperlink;
import com.google.gwt.user.client.ui.Label;
import com.google.gwt.user.client.ui.VerticalPanel;
import com.google.gwt.user.client.ui.Widget;
import com.google.gwtexpui.safehtml.client.SafeHtmlBuilder;

import com.googlesource.gerrit.plugins.xdocs.client.ChangeInfo.EditInfo;
import com.googlesource.gerrit.plugins.xdocs.client.ChangeInfo.RevisionInfo;

import java.util.List;

public abstract class XDocDiffScreen extends VerticalPanel {
  protected final String changeId;
  protected final String path;
  protected String revisionA;
  protected String revisionB;
  protected int patchSet;
  protected Integer base;
  private FlowPanel iconPanel;
  private FlowPanel additionalIconPanel;

  XDocDiffScreen(String changeId, final String patchSet, String path) {
    setStyleName("xdocs-panel");

    this.changeId = changeId;
    this.path = path;

    ChangeApi.getChangeInfo(changeId, new AsyncCallback<ChangeInfo>() {

      @Override
      public void onSuccess(final ChangeInfo change) {
        change.revisions().copyKeysIntoChildren("name");
        if (Plugin.get().isSignedIn()) {
          ChangeApi.edit(change._number(), new AsyncCallback<EditInfo>() {
            @Override
            public void onSuccess(EditInfo edit) {
              if (edit != null) {
                change.set_edit(edit);
                change.revisions().put(edit.name(), RevisionInfo.fromEdit(edit));
              }
              initRevisionsAndShow(change);
            }

            @Override
            public void onFailure(Throwable caught) {
              // never invoked
            }
          });
        } else {
          initRevisionsAndShow(change);
        }
      }

      private void initRevisionsAndShow(final ChangeInfo change) {
        parseRevisions(change, patchSet);
        if (revisionA == null) {
          ProjectApi.getCommitInfo(change.project(), change.current_revision(),
              new AsyncCallback<CommitInfo>() {
                @Override
                public void onSuccess(CommitInfo commit) {
                  if (commit.parents() != null) {
                    List<CommitInfo> parents = Natives.asList(commit.parents());
                    if (!parents.isEmpty()) {
                      revisionA = parents.get(0).commit();
                    }
                  }
                  show(change);
                }

                @Override
                public void onFailure(Throwable caught) {
                  // never invoked
                }
              });
        } else {
          show(change);
        }
      }

      private void show(ChangeInfo change) {
        addHeader(change);
        init();
        display(change);
      }

      @Override
      public void onFailure(Throwable caught) {
        showError("Unable to load change " + XDocDiffScreen.this.changeId
            + ": " + caught.getMessage());
      }
    });
  }

  protected abstract void display(ChangeInfo change);

  protected String getPath() {
    return path;
  }

  protected String getRevisionA() {
    return revisionA;
  }

  protected String getRevisionB() {
    return revisionB;
  }

  private void parseRevisions(ChangeInfo change, String patchSetString) {
    int i = patchSetString.indexOf("..");
    if (i > 0) {
      base = parsePatchSet(patchSetString.substring(0, i));
      revisionA = getRevision(change, base);
      if (patchSetString.length() > i + 2) {
        patchSet = parsePatchSet(patchSetString.substring(i + 2));
        revisionB = getRevision(change, patchSet);
      } else {
        throw new IllegalArgumentException("Invalid patch set: " + patchSetString);
      }
    } else {
      patchSet = parsePatchSet(patchSetString);
      revisionB = getRevision(change, patchSet);
    }
  }

  private static String getRevision(ChangeInfo change, int patchSet) {
    for (RevisionInfo rev : Natives.asList(change.revisions().values())) {
      if (rev.is_edit()) {
        return rev.commit().commit();
      }
      if (rev._number() == patchSet) {
        return rev.ref();
      }
    }
    throw new IllegalArgumentException("Patch set " + patchSet + " not found.");
  }

  private static int parsePatchSet(String patchSet) {
    try {
      return Integer.valueOf(patchSet);
    } catch (NumberFormatException e) {
      throw new IllegalArgumentException("Invalid patch set: " + patchSet);
    }
  }

  private void addHeader(ChangeInfo change) {
    HorizontalPanel p = new HorizontalPanel();
    p.setStyleName("xdocs-header");
    p.add(getPathHeader(change));

    iconPanel = new FlowPanel();
    iconPanel.setStyleName("xdocs-icon-panel");
    p.add(iconPanel);
    additionalIconPanel = new FlowPanel();
    iconPanel.add(additionalIconPanel);
    addNavigationButtons(change);

    add(p);
  }

  protected void init() {
  }

  private Widget getPathHeader(ChangeInfo change) {
    HorizontalPanel p = new HorizontalPanel();
    p.setStyleName("xdocs-file-header");
    p.add(new InlineHyperlink(change.project(), "/admin/projects/" + change.project()));
    p.add(new Label("/"));

    SafeHtmlBuilder html = new SafeHtmlBuilder();
    if (FileInfo.COMMIT_MSG.equals(path)) {
      html.append("Commit Message");
    } else {
      int s = path.lastIndexOf('/') + 1;
      html.append(path.substring(0, s));
      html.openElement("b");
      html.append(path.substring(s));
      html.closeElement("b");
    }
    p.add(new InlineHTML(html.toSafeHtml()));

    return p;
  }

  private void addNavigationButtons(final ChangeInfo change) {
    DiffApi.list(changeId, patchSet, base,
        new AsyncCallback<NativeMap<FileInfo>>() {
      @Override
      public void onSuccess(NativeMap<FileInfo> result) {
        JsArray<FileInfo> files = result.values();
        FileInfo.sortFileInfoByPath(files);
        int index = 0;
        for (int i = 0; i < files.length(); i++) {
          if (path.equals(files.get(i).path())) {
            index = i;
            break;
          }
        }

        FileInfo prevInfo = index == 0 ? null : files.get(index - 1);
        if (prevInfo != null) {
          iconPanel.add(createNavLink(XDocsPlugin.RESOURCES.goPrev(),
              change, patchSet, base, prevInfo));
        }

        iconPanel.add(createIcon(XDocsPlugin.RESOURCES.goUp(),
            "Up to change", toChange(change)));

        FileInfo nextInfo = index == files.length() - 1
            ? null
            : files.get(index + 1);
        if (nextInfo != null) {
          iconPanel.add(createNavLink(XDocsPlugin.RESOURCES.goNext(),
              change, patchSet, base, nextInfo));
        }
      }

      @Override
      public void onFailure(Throwable caught) {
        showError("Unable to load files of change " + changeId + ": "
            + caught.getMessage());
      }
    });
  }

  private InlineHyperlink createNavLink(ImageResource res,
      final ChangeInfo change, final int patchSet, final Integer base,
      final FileInfo file) {
    final InlineHyperlink link = createIcon(
        res, FileInfo.getFileName(file.path()),
        toFile(change, patchSet, base, file));
    XDocApi.checkHtml(XDocApi.getUrl(change.project(),
        getRevision(change, patchSet), file.path()),
        new AsyncCallback<VoidResult>() {
      @Override
      public void onSuccess(VoidResult result) {
        link.setTargetHistoryToken(
            toPreview(change, patchSet, base, file));
      }

      @Override
      public void onFailure(Throwable caught) {
      }
    });
    return link;
  }

  protected static InlineHyperlink createIcon(ImageResource res, String tooltip, String target) {
    InlineHyperlink l = new InlineHyperlink(
        AbstractImagePrototype.create(res).getHTML(), true, target);
    if (tooltip != null) {
      l.setTitle(tooltip);
    }
    return l;
  }

  protected void addIcon(InlineHyperlink icon) {
    additionalIconPanel.add(icon);
  }

  private String toPreview(ChangeInfo change, int patchSet,
      Integer base, FileInfo file) {
    String panel = getPanel();
    return "/x/" + Plugin.get().getName()
        + toPatchSet(change, patchSet, base)
        + file.path()
        + (panel != null ? "," + panel : "");
  }

  private String toFile(ChangeInfo change, int patchSet, Integer base,
      FileInfo file) {
    String panel = file.binary() ? "unified" : getPanel();
    return toPatchSet(change, patchSet, base)
        + file.path()
        + (panel != null ? "," + panel : "");
  }

  protected String getPanel() {
    return null;
  }

  private static String toPatchSet(ChangeInfo change, int patchSet, Integer base) {
    return toChange(change)
        + (base != null ? patchSet + ".." + base : patchSet) + "/";
  }

  private static String toChange(ChangeInfo change) {
    return "/c/" + change._number() + "/";
  }

  protected void showError(String message) {
    Label l = new Label(message);
    l.setStyleName("xdocs-error");
    add(l);
  }

  protected static int addRow(FlexTable table) {
    int row = table.getRowCount();
    table.insertRow(row);
    return row;
  }
}