<template>
  <div class="">
    <p>Mock</p>
    <v-toolbar flat height="42" class="toolbar-border-bottom">
      <v-toolbar-title>
        <v-breadcrumbs
          :items="[
            {
              text: nodes.env,
              disabled: true,
              href: '#',
            },
            {
              text: nodes.dbAlias,
              disabled: true,
              href: '#',
            },
            {
              text: nodes.table_name + ' (table)',
              disabled: true,
              href: '#',
            },
          ]"
          divider=">"
          small
        >
          <template #divider>
            <v-icon small color="grey lighten-2"> forward </v-icon>
          </template>
        </v-breadcrumbs>
      </v-toolbar-title>
      <v-spacer />
      <v-btn color="primary" small @click="loadColumnList">
        <v-icon left> refresh </v-icon>
        Refresh
      </v-btn>
      <v-btn color="primary" class="primary" small @click="addColumn"> New Column </v-btn>

      <v-btn color="primary" class="primary" small :disabled="!edited && !newTable" @click="applyChanges">
        <!-- Save &nbsp; -->
        {{ $t('general.save') }}
        <v-progress-circular v-if="progress.save" :indeterminate="progress.save" :size="20" color="secondary" />
      </v-btn>
      <v-btn small color="error " class="error text-right" @click="deleteTable('showDialog')">
        {{ $t('activity.deleteTable') }} &nbsp;

        <v-progress-circular
          v-if="progress.deleteTable"
          :indeterminate="progress.deleteTable"
          :size="20"
          color="secondary"
        />
      </v-btn>
      <v-btn icon class="text-right">
        <v-icon>mdi-help-circle-outline</v-icon>
      </v-btn>
    </v-toolbar>
    <v-card style="">
      <v-data-table
        dense
        :headers="headers"
        :items="columns"
        hide-default-header
        footer-props.items-per-page-options="30"
        class="elevation-20 column-table"
      >
        <template #header="{ props: { headers } }">
          <th v-for="header in headers" :key="header.title" class="pt-2 pb-0">
            <v-tooltip bottom>
              <template #activator="{ on }">
                <span v-on="on">{{ header.text }}</span>
              </template>
              <span>{{ header.title }}</span>
            </v-tooltip>
          </th>
        </template>

        <template #item="props">
          <tr :disabled="nodes.table_name === '_evolutions' || nodes.table_name === 'nc_evolutions'">
            <td>
              <v-edit-dialog
                :return-value.sync="props.item.column_name"
                @save="saveColumnName(props.item)"
                @cancel="cancel"
                @open="open"
                @close="close"
              >
                {{ props.item.column_name }}
                <template #input>
                  <v-text-field
                    v-model="props.item.column_name"
                    :disabled="props.item.rcn"
                    :rules="[max25chars]"
                    :label="$t('general.edit')"
                    single-line
                  />
                </template>
              </v-edit-dialog>
            </td>
            <td>
              <!--              <v-autocomplete-->
              <!--                :full-width="false"-->
              <!--                v-model="props.item.dtx"-->
              <!--                :items="dataTypes"-->
              <!--                @change="onDataTypeChange(props.item,props.index)"-->
              <!--                dense-->
              <!--              ></v-autocomplete>-->
              <v-autocomplete
                v-model="props.item.dt"
                :full-width="false"
                :items="dataTypes"
                dense
                @change="onDataTypeChange(props.item, props.index)"
              />
            </td>
            <!--            <td>-->
            <!--              <v-edit-dialog-->
            <!--                :return-value.sync="props.item.data_type_x_specific"-->
            <!--                lazy-->
            <!--                @save="save"-->
            <!--                @cancel="cancel"-->
            <!--                @open="open"-->
            <!--                @close="close"-->
            <!--                v-if="props.item.dtx==='specificType'"-->
            <!--              >-->
            <!--                {{ props.item.ct}}-->
            <!--                <template v-slot:input>-->
            <!--                  <v-text-field-->
            <!--                    v-model="props.item.ct"-->
            <!--                    :rules="[max25chars]"-->
            <!--                    label="Edit"-->
            <!--                    single-line-->
            <!--                  ></v-text-field>-->
            <!--                </template>-->
            <!--              </v-edit-dialog>-->
            <!--            </td>-->
            <td>
              <v-edit-dialog
                v-if="props.item.dtxp"
                :return-value.sync="props.item.dtxp"
                lazy
                @save="savePrecision(props.item)"
                @cancel="cancelPrecision"
                @open="openPrecision"
                @close="closePrecision"
              >
                {{ props.item.dtxp }}
                <template #input>
                  <v-text-field
                    v-model="props.item.dtxp"
                    :rules="[max25chars]"
                    :label="$t('general.edit')"
                    single-line
                  />
                </template>
              </v-edit-dialog>
            </td>
            <td>
              <v-edit-dialog
                v-if="props.item.dtxs"
                :return-value.sync="props.item.dtxs"
                lazy
                @save="saveScale(props.item)"
                @cancel="cancelScale"
                @open="openScale"
                @close="closeScale"
              >
                {{ props.item.dtxs }}
                <template #input>
                  <v-text-field
                    v-model="props.item.dtxs"
                    :rules="[max25chars]"
                    :label="$t('general.edit')"
                    single-line
                  />
                </template>
              </v-edit-dialog>
            </td>
            <td>
              <v-checkbox v-model="props.item.pk" solo height="44" color="" @change="onCheckboxChangePk(props.item)" />
            </td>
            <td>
              <v-checkbox v-model="props.item.rqd" solo color="" @change="onCheckboxChangeNN(props.item)" />
            </td>
            <td>
              <v-checkbox
                v-model="props.item.un"
                :disabled="colPropUNDisabled(props.item)"
                solo
                color=""
                @change="onCheckboxChangeUN(props.item)"
              />
            </td>
            <td>
              <v-checkbox
                v-model="props.item.ai"
                :disabled="colPropAIDisabled(props.item)"
                solo
                color=""
                @change="onCheckboxChangeAI(props.item)"
              />
            </td>

            <td>
              <p v-if="props.item.rtn" row wrap>
                {{ props.item.rtn }}
                <v-icon small @click="createNewOrEditRelation(props.item)"> mdi-table-edit </v-icon>
                <v-icon small color="error" @click="deleteRelation('showDialog', props.item)">
                  mdi-delete-forever
                </v-icon>
              </p>

              <v-icon v-else-if="!props.item.pk" color="" @click="createNewOrEditRelation(props.item)"> add </v-icon>

              <v-icon v-else disabled color="grey"> add </v-icon>
            </td>
            <td>
              <v-edit-dialog
                :return-value.sync="props.item.cdf"
                large
                lazy
                persistent
                @save="saveDefaultValue(props.item)"
                @cancel="cancel"
                @open="open"
                @close="close"
              >
                <!--                <div v-if="props.item.rqd">{{ props.item.cdf }}</div>-->
                <div v-if="props.item.pk" />
                <div v-else-if="!props.item.cdf && !props.item.rqd">NULL</div>
                <div v-else>
                  {{ props.item.cdf }}
                </div>
                <!--                <template #input>-->
                <!--                  <div class="mt-3 title">-->
                <!--                    Update column_default-->
                <!--                  </div>-->
                <!--                </template>-->
                <template #input>
                  <v-text-field v-model="props.item.cdf" :label="$t('general.edit')" single-line counter autofocus />
                </template>
              </v-edit-dialog>
            </td>
            <td>
              <v-icon color="error" icon @click="deleteColumn('showDialog', props.index, props.item)">
                mdi-delete-forever
              </v-icon>
            </td>
          </tr>
        </template>
      </v-data-table>
    </v-card>
    <addRelationDlg
      v-if="dialogShow"
      :nodes="nodes"
      :column="selectedColForNewRelation"
      heading="Relation Column "
      :dialog-show="dialogShow"
      :mtd-dialog-submit="mtdNewRelationDlgSubmit"
      :mtd-dialog-cancel="mtdNewRelationDlgCancel"
    />
    <span v-else />
    <dlgLabelSubmitCancel
      v-if="columnDeleteDlg"
      type="primary"
      :dialog-show="columnDeleteDlg"
      :actions-mtd="deleteColumn"
      heading="Click Submit to Delete the Column"
    />
    <dlgLabelSubmitCancel
      v-if="relationDeleteDlg"
      type="primary"
      :dialog-show="relationDeleteDlg"
      :actions-mtd="deleteRelation"
      heading="Click Submit to Delete the Relation"
    />
  </div>
</template>

<script>
import { mapGetters, mapActions } from 'vuex';
import addRelationDlg from '../dlgs/DlgAddRelation.vue';
import dlgLabelSubmitCancel from '../../utils/DlgLabelSubmitCancel.vue';

export default {
  components: { addRelationDlg, dlgLabelSubmitCancel },
  data() {
    return {
      progress: {
        save: false,
        deleteTable: false,
        refresh: false,
      },
      edited: false,
      columnDeleteDlg: false,
      selectedColForDelete: null,
      relationDeleteDlg: false,
      selectedColForRelationDelete: null,
      columns: [],
      dataTypes: [],
      headers: [
        {
          text: 'Column',
          title: 'Column name',
          value: 'cn',
          sortable: false,
          width: '1%',
        },
        { text: 'Data Type', title: 'Data Type', value: 'dt', sortable: false, width: '10%' },
        // {text: "Type",title:', value: "dt", sortable: false, width: "10%"},
        { text: 'Length/Values', title: 'Length/Values', value: 'dt', sortable: false, width: '10%' },
        { text: 'Scale', title: 'Scale', value: 'dt', sortable: false, width: '10%' },
        { text: 'PK', title: 'Primary Key', value: 'pk', sortable: false, width: '1%' },
        { text: 'NN', title: 'Not NULL', value: 'rqd', sortable: false, width: '1%' },
        { text: 'UN', title: 'Unsigned', value: 'unsigned', sortable: false, width: '1%' },
        { text: 'AI', title: 'Auto Increment', value: 'ai', sortable: false, width: '1%' },
        { text: 'Foreign Key', title: 'Foreign Key', value: '', sortable: false, width: '20%' },
        {
          text: 'Default',
          title: 'Default Value',
          value: 'cdf',
          sortable: false,
          width: '10%',
        },
        { text: '', title: 'Action', value: '', sortable: false, width: '1%' },
      ],
      max25chars: v => v.length <= 150 || 'Input too long!',
      dialogShow: false,
      selectedColForNewRelation: null,
    };
  },
  methods: {
    ...mapActions({
      loadTablesFromChildTreeNode: 'project/loadTablesFromChildTreeNode',
    }),
    async onCheckboxChange() {
      this.edited = true;
    },

    async onCheckboxChangePk(col) {
      this.edited = true;
      col.altered = col.altered || 2;

      col.cdf = null;
      col.rqd = true;
    },
    colPropAIDisabled(col) {
      if (col.dtx === 'integer' || col.dtx === 'bigInteger' || col.dtx === 'specificType') {
        for (let i = 0; i < this.columns.length; ++i) {
          if (this.columns[i].column_name !== col.column_name && this.columns[i].ai) {
            return true;
          }
        }
        return false;
      } else {
        return true;
      }
    },

    colPropUNDisabled(col) {
      if (col.dtx === 'integer' || col.dtx === 'bigInteger' || col.dt.includes('int')) {
        return false;
      } else {
        return true;
      }
    },

    onCheckboxChangeAI(col) {
      console.log(col);
      if (col.dt === 'int' || col.dt === 'bigint' || col.dt === 'smallint' || col.dt === 'tinyint') {
        col.altered = col.altered || 2;
      }

      if (!col.ai) {
        col.dtx = 'specificType';
      } else {
        col.dtx = '';
      }

      this.edited = true;
    },

    onCheckboxChangeNN(col) {
      col.altered = col.altered || 2;
      this.edited = true;
    },

    onCheckboxChangeUN(col) {
      col.altered = col.altered || 2;
      this.edited = true;
    },

    async onDataTypeChange(column, index) {
      this.edited = true;
      column.altered = column.altered || 2;
      column.rqd = false;
      column.pk = false;
      column.ai = false;
      column.cdf = null;
      column.dtxp = ' ';
      column.dtxs = ' ';

      column.dtx = 'specificType';

      console.log('data type changed', index, column);
    },
    async loadColumnList() {
      this.edited = false;
      if (this.newTable) {
        this.columns = [
          {
            cn: 'id',
            dt: 'int',
            dtx: 'integer',
            ct: 'int(11)',
            nrqd: false,
            rqd: true,
            ck: false,
            pk: true,
            un: true,
            ai: true,
            cdf: null,
            clen: null,
            np: 10,
            ns: 0,
            // dp: null,
            // data_type_x_specific: '',
            dtxp: '10',
            dtxs: '',
          },
          {
            cn: 'title',
            dt: 'varchar',
            dtx: 'specificType',
            ct: 'varchar(45)',
            nrqd: true,
            rqd: false,
            ck: false,
            pk: false,
            un: false,
            ai: false,
            cdf: null,
            clen: 45,
            np: null,
            ns: null,
            // dp: null
            // data_type_x_specific: 'specificType',
            dtxp: '45',
            dtxs: '',
          },
        ];
        return;
      }
      // console.log("env: this.nodes.env", this.nodes.env, this.nodes.dbAlias);
      // const client = await this.sqlMgr.projectGetSqlClient({
      //     env: this.nodes.env,
      //     dbAlias: this.nodes.dbAlias
      // });
      // const result = await client.columnList({
      //     tn: this.nodes.table_name
      // });

      const result = await this.sqlMgr.sqlOp(
        {
          env: this.nodes.env,
          dbAlias: this.nodes.dbAlias,
        },
        'columnList',
        {
          tn: this.nodes.table_name,
        }
      );

      console.log('table ', result.data.list);
      const columns = result.data.list;

      // const relationsResult = await client.relationList({
      //     tn: this.nodes.table_name
      // });

      const relationsResult = await this.sqlMgr.sqlOp(
        {
          env: this.nodes.env,
          dbAlias: this.nodes.dbAlias,
        },
        'relationList',
        {
          tn: this.nodes.table_name,
        }
      );

      const relations = relationsResult.data.list;
      console.log('relations: ', relations);

      for (let i = 0; i < relations.length; i++) {
        const relation = relations[i];
        for (let i = 0; i < columns.length; i++) {
          const column = columns[i];

          if (column.column_name === relation.column_name) {
            // column.rcn = relation.rcn;
            // column.rtn = relation.rtn;
            columns[i] = { ...column, ...relation };
          }
        }
      }

      this.columns = JSON.parse(JSON.stringify(columns));
      this.originalColumns = [...columns];
      console.log(this.columns);
    },
    async loadDataTypes() {
      const client = await this.sqlMgr.projectGetSqlClient({
        env: this.nodes.env,
        dbAlias: this.nodes.dbAlias,
      });
      const result = client.getKnexDataTypes();
      this.dataTypes = result.data.list;
    },
    saveColumnName(col) {
      this.edited = true;
      col.altered = col.altered || 8;

      this.snack = true;
      this.snackColor = 'success';
      this.snackText = 'Data saved';
    },
    save(col) {
      this.edited = true;
      col.altered = col.altered || 2;

      this.snack = true;
      this.snackColor = 'success';
      this.snackText = 'Data saved';
    },
    cancel() {
      this.snack = true;
      this.snackColor = 'error';
      this.snackText = 'Canceled';
    },
    open() {
      this.snack = true;
      this.snackColor = 'info';
      this.snackText = 'Dialog opened';
    },
    close() {
      console.log('Dialog closed');
    },

    saveDefaultValue(col) {
      this.edited = true;
      col.altered = col.altered || 2;
      // col.rqd = false;

      this.snack = true;
      this.snackColor = 'success';
      this.snackText = 'Data saved';
    },

    savePrecision(col) {
      console.log(col);
      col.altered = col.altered || 2;
      this.edited = true;
      this.snack = true;
      this.snackColor = 'success';
      this.snackText = 'Data saved';
    },
    cancelPrecision() {
      this.snack = true;
      this.snackColor = 'error';
      this.snackText = 'Canceled';
    },
    openPrecision() {
      this.snack = true;
      this.snackColor = 'info';
      this.snackText = 'Dialog opened';
    },
    closePrecision() {
      console.log('Dialog closed');
    },

    saveScale(col) {
      if (col.dtx === 'float' || col.dtx === 'decimal' || col.dtx === 'specifcType') {
        col.altered = col.altered || 2;
        this.edited = true;
        this.snack = true;
        this.snackColor = 'success';
        this.snackText = 'Data saved';
      }
    },
    cancelScale() {
      this.snack = true;
      this.snackColor = 'error';
      this.snackText = 'Canceled';
    },
    openScale() {
      this.snack = true;
      this.snackColor = 'info';
      this.snackText = 'Dialog opened';
    },
    closeScale() {
      console.log('Dialog closed');
    },

    removeUnsigned(columns) {
      for (let i = 0; i < columns.length; ++i) {
        if (columns[i].altered === 1 && !(columns[i].dt === 'int' || columns[i].dt === 'bigint')) {
          columns[i].un = false;
          console.log('>> resetting unsigned value', columns[i].column_name);
        }
        console.log(columns[i].column_name);
      }
    },
    addColumn() {
      this.edited = true;
      this.columns.push({
        cn: 'title' + this.columns.length,
        dt: 'int',
        dtx: 'specificType',
        ct: 'integer(10)',
        nrqd: true,
        rqd: false,
        ck: false,
        pk: false,
        un: false,
        ai: false,
        cdf: null,
        clen: 45,
        np: null,
        ns: null,
        // data_type_x_specific: ' ',
        dtxp: '10',
        dtxs: ' ',
        altered: 1,
      });
    },
    async deleteColumn(action = '', index, column) {
      if (action === 'showDialog') {
        this.columnDeleteDlg = true;
        this.selectedColForDelete = { index, column };
      } else if (action === 'hideDialog') {
        this.columnDeleteDlg = false;
      } else {
        if (this.columns[this.selectedColForDelete.index].altered === 1) {
          // newly added column no need to remove fromd db
          this.columns.splice(this.selectedColForDelete.index, 1);
        } else {
          const columns = JSON.parse(JSON.stringify(this.columns));
          columns[this.selectedColForDelete.index].altered = 4;
          await this.sqlMgr.sqlOpPlus(
            {
              env: this.nodes.env,
              dbAlias: this.nodes.dbAlias,
            },
            'tableUpdate',
            {
              tn: this.nodes.table_name,
              originalColumns: this.originalColumns,
              columns,
            }
          );
          this.columns.splice(this.selectedColForDelete.index, 1);
        }
        this.columnDeleteDlg = false;
        this.selectedColForDelete = null;
      }
    },
    async applyChanges() {
      this.progress.save = true;
      await this.sqlMgr.projectGetSqlClient({
        env: this.nodes.env,
        dbAlias: this.nodes.dbAlias,
      });
      if (this.newTable) {
        this.removeUnsigned(this.columns);
        // let result = await this.sqlMgr.sqlOpPlus(
        //   {
        //     env: this.nodes.env,
        //     dbAlias: this.nodes.dbAlias
        //   },
        //   "tableCreate",
        //   {
        //     tn: this.nodes.table_name,
        //     columns: this.columns
        //   }
        // );

        await this.$store.dispatch('sqlMgr/ActSqlOpPlus', [
          {
            env: this.nodes.env,
            dbAlias: this.nodes.dbAlias,
          },
          'tableCreate',
          {
            tn: this.nodes.table_name,
            columns: this.columns,
          },
        ]);
        // const result = await client.tableCreate({
        //   tn: this.nodes.table_name,
        //   columns: this.columns
        // });
        this.mtdNewTableUpdate(false);
        // console.log("result", result, this.nodes);
        await this.loadTablesFromChildTreeNode({
          _nodes: {
            ...this.nodes,
          },
        });
      } else {
        console.log('this.columns[index].altered before', this.columns);
        // const result = await client.tableUpdate({
        //   tn: this.nodes.table_name,
        //   originalColumns: this.originalColumns,
        //   columns: this.columns
        // });
        this.removeUnsigned(this.columns);
        // let result = await this.sqlMgr.sqlOpPlus(
        //     {
        //         env: this.nodes.env,
        //         dbAlias: this.nodes.dbAlias
        //     },
        //     "tableUpdate",
        //     {
        //         tn: this.nodes.table_name,
        //         originalColumns: this.originalColumns,
        //         columns: this.columns
        //     }
        // );

        const result = await this.$store.dispatch('sqlMgr/ActSqlOpPlus', [
          {
            env: this.nodes.env,
            dbAlias: this.nodes.dbAlias,
          },
          'tableUpdate',
          {
            tn: this.nodes.table_name,
            originalColumns: this.originalColumns,
            columns: this.columns,
          },
        ]);
        console.log('update table result', result);
      }
      this.progress.save = false;
      await this.loadColumnList();
    },
    createNewOrEditRelation(column) {
      console.log(column);
      this.selectedColForNewRelation = { ...column };
      this.dialogShow = true;
    },
    async mtdNewRelationDlgSubmit(relationObject) {
      try {
        await this.sqlMgr.projectGetSqlClient({
          env: this.nodes.env,
          dbAlias: this.nodes.dbAlias,
        });

        if (relationObject.updateRelation) {
          // update existing relation
          alert('Not Implemented yet');
        } else {
          // const result = await client.relationCreate(relationObject);

          const result = await this.sqlMgr.sqlOpPlus(
            {
              env: this.nodes.env,
              dbAlias: this.nodes.dbAlias,
            },
            'relationCreate',
            relationObject
          );
          console.log('relationCreate result: ', result);
        }

        await this.loadColumnList();
        this.selectedColForNewRelation = null;
        this.dialogShow = false;
      } catch (error) {
        console.error('relationCreate error: ', error);
      }
    },
    mtdNewRelationDlgCancel() {
      this.dialogShow = false;
      this.selectedColNameForNewRelation = '';
    },
    async deleteRelation(action = '', column) {
      if (action === 'showDialog') {
        this.relationDeleteDlg = true;
        this.selectedColForRelationDelete = column;
      } else if (action === 'hideDialog') {
        this.relationDeleteDlg = false;
        this.selectedColForRelationDelete = null;
      } else {
        await this.sqlMgr.projectGetSqlClient({
          env: this.nodes.env,
          dbAlias: this.nodes.dbAlias,
        });

        // const result = await client.relationDelete({
        //   childColumn: column.column_name,
        //   childTable: this.nodes.table_name,
        //   parentTable: column.rtn,
        //   parentColumn: column.rcn,
        //   foreignKeyName: column.cstn
        // });
        const result = await this.sqlMgr.sqlOpPlus(
          {
            env: this.nodes.env,
            dbAlias: this.nodes.dbAlias,
          },
          'relationDelete',
          {
            childColumn: this.selectedColForRelationDelete.column_name,
            childTable: this.nodes.table_name,
            parentTable: this.selectedColForRelationDelete.rtn,
            parentColumn: this.selectedColForRelationDelete.rcn,
            foreignKeyName: this.selectedColForRelationDelete.cstn,
          }
        );
        console.log('relationDelete result ', result);
        await this.loadColumnList();
        this.relationDeleteDlg = false;
        this.selectedColForRelationDelete = null;
      }
    },
  },
  computed: { ...mapGetters({ sqlMgr: 'sqlMgr/sqlMgr' }) },

  beforeCreated() {},
  watch: {},
  async created() {
    await this.loadColumnList();
    this.loadDataTypes();
  },
  mounted() {},
  beforeDestroy() {},
  destroy() {},
  directives: {},
  validate({ params }) {
    return true;
  },
  head() {
    return {};
  },
  props: ['nodes', 'newTable', 'mtdNewTableUpdate', 'deleteTable'],
};
</script>

<style scoped></style>
<!--
/**
 * @copyright Copyright (c) 2021, Xgene Cloud Ltd
 *
 * @author Naveen MR <oof1lab@gmail.com>
 * @author Pranav C Balan <pranavxc@gmail.com>
 *
 * @license GNU AGPL version 3 or any later version
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 */
-->
