import { Value } from 'slate';

import Plain from 'slate-plain-serializer';

import { Editor } from 'slate-react';

import React from 'react';

import { Trans, withNamespaces } from 'react-i18next';

import * as R from 'ramda';

import HtmlSerializer from './HtmlSerializer';

import AnnotationPlugin from './AnnotationPlugin';

import CategoriesTooltip from './CategoriesTooltip';

import './SlateEditor.css';

import { now } from '../../utils';

import { defaultAnnotationsCategories } from '../../constants';

const plugins = [];

/**

 * Define the default node type.

 */

const DEFAULT_NODE = 'paragraph'

/**

 * Define a schema.

 *

 * @type {Object}

 */

// TODO Check if we can move this to the plugin using the schema option

// https://docs.slatejs.org/reference/plugins/plugin.html#schema

const schema = {

  nodes: {

    'bulleted-list': props => <ul {...props.attributes}>{props.children}</ul>,

    'list-item': props => <li {...props.attributes}>{props.children}</li>,

    'numbered-list': props => <ol {...props.attributes}>{props.children}</ol>,

  },

  marks: {

    bold: {

      fontWeight: 'bold'

    },

    category: props => {

      const data = props.mark.data;

    },

    italic: {

      fontStyle: 'italic'

    },

    underlined: {

      textDecoration: 'underlined'

    }

  }

}

const initialValue = Value.fromJSON({

  document: {

    nodes: [

      {

        object: 'block',

        type: 'paragraph',

        nodes: [

          {

            object: 'text',

            leaves: [

              {

                text: '',

              },

            ],

          },

        ],

      },

    ],

  },

})

/**

 *

 * @type {Component}

 */

class SlateEditor extends React.Component {

  /**

   * Deserialize the initial editor state.

   *

   * @type {Object}

   */

  constructor(props) {

    super(props);

    const annotationPlugin = AnnotationPlugin({

      onChange: (text, start, end) => {

        this.setState({

          currentSelectionText: text,

          currentSelectionStart: start,

          currentSelectionEnd: end,

        });

      }

    });

    this.state = {

      value: props.note ? Value.fromJSON(initialValue) : Plain.deserialize(''),

      startedAt: null,

      finishedAt: null,

      currentSelectionText: '',

      currentSelectionStart: 0,

      currentSelectionEnd: 0,

      hoveringMenu: null,

      isPortalOpen: false,

      categories: [],

      isCheckboxChecked: false,

      enterKeyValue: 0,

    };

  }

  componentDidMount = () => {

    this.updateMenu();

    this.focus();

  }

  componentDidUpdate = () => {

    this.updateMenu();

  }

   /**

   * On change, save the new state.

   *

   * @param {Change} change

   */

    let newState = {

      value: value,

      startedAt: this.state.startedAt

    };

    // Reset timers when the text is empty

    if (isEmpty) {

      Object.assign(newState, {

        startedAt: null,

        finishedAt: null

      });

    } else {

      Object.assign(newState, { finishedAt: now() });

    }

    // Store start time once when the first character is typed

    if (!isEmpty && this.state.startedAt === null) {

      Object.assign(newState, { startedAt: now() });

    }

    const oldState = R.clone(this.state);

  }

  /**

   * Check if the current selection has a mark with `type` in it.

   *

   * @param {String} type

   * @return {Boolean}

   */

  hasMark = type => {

  }

  /**

   * Check if the any of the currently selected blocks are of `type`.

   *

   * @param {String} type

   * @return {Boolean}

   */

  hasBlock = type => {

    const { value } = this.state

    return value.blocks.some(node => node.type === type)

  }

  asPlain = () => {

    return Plain.serialize(this.state.value);

  }

  asRaw = () => {

    return JSON.stringify(this.state.value.toJSON());

  }

  asHtml = () => {

    return HtmlSerializer.serialize(this.state.value);

  }

  asCategories = () => {

    return this.state.categories

  }

  removeCategory = (categories, key, text) => {

    const categoryIndex = categories.findIndex(category => category.key === key && category.text === text)

    return categories.delete(categoryIndex)

  }

  clear = () => {

    const value = Plain.deserialize('');

  }

  focus = () => {

    }

  }

  /**

   * When a mark button is clicked, toggle the current mark.

   *

   * @param {Event} e

   * @param {String} type

   */

  onClickMark = (e, type) => {

  }

  /**

   * When a block button is clicked, toggle the block type.

   *

   * @param {Event} e

   * @param {String} type

   */

  onClickBlock = (e, type) => {

    e.preventDefault()

    // Handle everything but list buttons.

    if (type !== 'bulleted-list' && type !== 'numbered-list') {

      const isActive = this.hasBlock(type)

      const isList = this.hasBlock('list-item')

      if (isList) {

          .setBlocks(isActive ? DEFAULT_NODE : type)

          .unwrapBlock('bulleted-list')

          .unwrapBlock('numbered-list')

      }

      else {

          .setBlocks(isActive ? DEFAULT_NODE : type)

      }

    }

    // Handle the extra wrapping required for list buttons.

    else {

      const isList = this.hasBlock('list-item')

      const isType = value.blocks.some((block) => {

        return !!document.getClosest(block.key, parent => parent.type === type)

      })

      if (isList && isType) {

          .setBlocks(DEFAULT_NODE)

          .unwrapBlock('bulleted-list')

          .unwrapBlock('numbered-list')

      } else if (isList) {

          .unwrapBlock(type === 'bulleted-list' ? 'numbered-list' : 'bulleted-list')

          .wrapBlock(type)

      } else {

          .setBlocks('list-item')

          .wrapBlock(type)