import { Value } from 'slate'

import Plain from 'slate-plain-serializer'

import { Editor } from 'slate-react'

import React from 'react'

import { Portal } from 'react-portal'

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;

      return <span style={{ backgroundColor: data.color }}>{props.children}</span>

    },

    italic: {

      fontStyle: 'italic'

    },

    underlined: {

      textDecoration: 'underlined'

    }

  }

}

const initialValue = Value.fromJSON({

  document: {

    nodes: [

      {

        object: 'block',

        type: 'paragraph',

        nodes: [

          {

            object: 'text',

            leaves: [

              {

                text: '',

              },

            ],

          },

        ],

      },

    ],

  },

})

/**

 * The rich text example.

 *

 * @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,

        });

      }

    });

    plugins.push(annotationPlugin);

    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

   */

  onChange = ({value}) => {

    let newState = {

      value: value,

      startedAt: this.state.startedAt

    };

    const isEmpty = value.document.length === 0;

    // 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() });

    }

    this.setState(newState)

    if (typeof this.props.onChange === 'function') {

      this.props.onChange(newState);

    }

  }

  /**

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

   *

   * @param {String} type

   * @return {Boolean}

   */

  hasMark = type => {

    const { value } = this.state

    return value.activeMarks.some(mark => mark.type === 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('');

    this.onChange({value});

  }

  focus = () => {

    this.refs.editor.focus();

  }

      /**

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

   *

   * @param {Event} e

   * @param {String} type

   */

  onClickMark = (e, type) => {

    e.preventDefault()

    const { value } = this.state

    let { categories } = this.state

    let isPortalOpen = false;

    if (type === 'category') {

      // Can't use toggleMark here, because it expects the same object

      // @see https://github.com/ianstormtaylor/slate/issues/873

      if (this.hasMark('category')) {

        const categoryMarks = value.activeMarks.filter(mark => mark.type === 'category')

        categoryMarks.forEach(mark => {

          const key = mark.data.key;

          const text = mark.data.text;

          categories = this.removeCategory(categories, key, text)

          const change = value.change().removeMark(mark)

          this.onChange(change)

        })

      } else {

        isPortalOpen = !this.state.isPortalOpen;

      }

    } else {

      const change = value.change().toggleMark(type)

      this.onChange(change)

    }

    this.setState({

      state: value.change,

      isPortalOpen: isPortalOpen,

      categories: categories

    })

  }

  /**

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

   *

   * @param {Event} e

   * @param {String} type

   */

  onClickBlock = (e, type) => {

    e.preventDefault()

    const { value } = this.state

    const change = value.change()

    const { document } = value

    // 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) {

        change

          .setBlocks(isActive ? DEFAULT_NODE : type)

          .unwrapBlock('bulleted-list')

          .unwrapBlock('numbered-list')

      }

      else {

       change

          .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) {

       change

          .setBlocks(DEFAULT_NODE)

          .unwrapBlock('bulleted-list')

          .unwrapBlock('numbered-list')

      } else if (isList) {

        change

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

          .wrapBlock(type)

      } else {

        change

          .setBlocks('list-item')

          .wrapBlock(type)

      }

    }

    this.onChange(change)

  }

  onPortalOpen = (portal) => {

    // When the portal opens, cache the menu element.

    this.setState({ hoveringMenu: portal.firstChild })

  }

  onPortalClose = (portal) => {

    let { value } = this.state

    this.setState({

      value: value.change,

      isPortalOpen: false

    })

  }

  onCategoryClick = (category) => {

    const { value, currentSelectionText, currentSelectionStart, currentSelectionEnd } = this.state;

    const change = value.change()

    let { categories } = this.state;

    const categoryMarks = value.activeMarks.filter(mark => mark.type === 'category')

    categoryMarks.forEach(mark => change.removeMark(mark));

    change.addMark({

      type: 'category',

      data: {

        text: currentSelectionText,

        selection: {

          start: currentSelectionStart,

          end: currentSelectionEnd,

        },

        color: category.color,

        key: category.key

      }

    })

    Object.assign(category, {

      text: currentSelectionText,

      selection: {

        start: currentSelectionStart,

        end: currentSelectionEnd,

      },

    });

    categories = categories.push(category);