<!--
@license
Copyright (C) 2016 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.
-->

<link rel="import" href="/bower_components/iron-autogrow-textarea/iron-autogrow-textarea.html">
<link rel="import" href="/bower_components/polymer/polymer.html">
<link rel="import" href="../../../behaviors/fire-behavior/fire-behavior.html">
<link rel="import" href="../../shared/gr-dialog/gr-dialog.html">
<link rel="import" href="../../../styles/shared-styles.html">
<link rel="import" href="../../plugins/gr-endpoint-decorator/gr-endpoint-decorator.html">
<link rel="import" href="../../shared/gr-js-api-interface/gr-js-api-interface.html">

<dom-module id="gr-confirm-revert-dialog">
  <template>
    <style include="shared-styles">
      :host {
        display: block;
      }
      :host([disabled]) {
        opacity: .5;
        pointer-events: none;
      }
      label {
        cursor: pointer;
        display: block;
        width: 100%;
      }
      .revertSubmissionLayout {
        display: flex;
      }
      .label {
        margin-left: var(--spacing-m);
        margin-bottom: var(--spacing-m);
      }
      iron-autogrow-textarea {
        font-family: var(--monospace-font-family);
        font-size: var(--font-size-mono);
        line-height: var(--line-height-mono);
        width: 73ch; /* Add a char to account for the border. */
      }
    </style>
    <gr-dialog
        confirm-label="Revert"
        on-confirm="_handleConfirmTap"
        on-cancel="_handleCancelTap">
      <div class="header" slot="header">Revert Merged Change</div>
      <div class="main" slot="main">
        <div class="revertSubmissionLayout">
          <input
            name="revertOptions"
            type="radio"
            id="revertSingleChange"
            on-change="_handleRevertSingleChangeClicked"
            checked="[[_computeIfSingleRevert(_revertType)]]">
          <label for="revertSingleChange" class="label revertSingleChange">
            Revert single change
          </label>
        </div>
        <template is="dom-if" if="[[_showRevertSubmission]]">
          <div on-click="_handleRevertSubmissionClicked" class="revertSubmissionLayout">
            <input
              name="revertOptions"
              type="radio"
              id="revertSubmission"
              checked="[[_computeIfRevertSubmission(_revertType)]]">
            <label for="revertSubmission" class="label revertSubmission">
              Revert entire submission ([[changes.length]] Changes)
            </label>
        </template>
        <gr-endpoint-decorator name="confirm-revert-change">
          <!-- Duplicating the text-area as a plugin in the case of a single
          revert will override the entire textarea which should not happen
          for multiple revert -->
          <template is="dom-if" if="[[_computeIfSingleRevert(_revertType)]]">
            <label for="messageInput">
                Revert Commit Message
              </label>
            <iron-autogrow-textarea
              id="messageInput"
              class="message"
              autocomplete="on"
              max-rows="15"
              bind-value="{{message}}"></iron-autogrow-textarea>
          </template>
        </gr-endpoint-decorator>
        <template is="dom-if" if="[[_computeIfRevertSubmission(_revertType)]]">
          <label for="messageInput">
            Revert Commit Message
          </label>
          <iron-autogrow-textarea
              id="messageInput"
              class="message"
              autocomplete="on"
              max-rows="15"
              bind-value="{{message}}"></iron-autogrow-textarea>
        </template>
      </div>
    </gr-dialog>
    <gr-js-api-interface id="jsAPI"></gr-js-api-interface>
  </template>
  <script src="gr-confirm-revert-dialog.js"></script>
</dom-module>
