8kun Bakertools v0.7.1

/*
==8Kun Baker Tools v0.7.1==
For God and Country! WWG1WGA

==Features:==
'''Post Highlighting'''
* Highlight posts that are marked notable (I.E. someone has replied and said
  notable) in light green
* Highlight nominating posts in dark green
* Highlight nominating posts in posts mentions in light green
* Highlight Q Posts in yellow
* Highlight Q posts in mentions (I.E. on posts that get (YOU)'ed)
* Highlight links to Q Posts in sparkle (Like q's trip)
* Highlight previous bread links in blue

'''Navigation'''
* Cycle through Q Posts
* Cycle through (You)'s
* Cycle through own posts
* Jump To Bottom Link
* Jump To Bottom Top link
* NEW IN v0.7.0 Jump to last reading location (like when you post and it
  sends you to bottom, you can jump right back)
* Easy access to Breads via Bread List window
* Scrollbar navigation shows location of Q/You/Notable/etc posts
  * NEW IN v0.7.0: Hover over post marker to preview post
  * Click on a post marker in scrollbar to jump to post

'''Filtering'''
* Filter to only nominating and notable posts, Q posts, Q replies
* Option to blur images until hover
* Image blacklist (AKA the NOPE button)
* NEW IN v0.7.0: SpamFader with multiple spam detection strategies:
  * NameFag strategy: Marks namefags as spam
  * Breadshitter strategy: Marks bread shitters as spam
  * High post count strategy: Marks those with high post count as spam
  * Flood fag strategy: Marks those who post in short intervals as spam
  * Mark user as not spam button
  * Spam badges tell WHY the algorithm marked as post as spam. TRANSPARENCY!

'''Customizable'''
* NEW IN v0.7.0: Customizable post highlighting colors
* Hide/Show features
* Settings saved in localStorage

'''Notables'''
* Generate notables post
* Adds "Notable Nomination" button to posts that opens the
  Quick Reply box and prefills it with a BAKER NOTABLE Template

'''Stats'''
  * Thread stats overlay with
    * color coded reply count that goes from green to red as bread ages
    * UID Count
  * Post rate chart shows how many posts per min

==To Install:==
1. Copy this source code
2. Go to 8kun
3. Click "Options" in the top right
4. Choose "User JS" tab
5. Paste Baker tools JS
6. WWG1WGA

==Changelog:==
'''0.7.1'''
* Fix notable navigation in boardlist checkbox not working
* Differentiate between previous and newer breads when highlighting

'''0.7.0'''
* Switched color scheme to match other tools
* Post Per Minute Graph
* Spam Fading with multiple strategies and spam badges to tell why post is spam
* Allow customization of post highligting colors
* Add go back to last reading location button
* Improve Q post detection (all past trip codes)
* Add post preview on hover to Scrollbar Navigation
* Navigation controls are now aware of current page location
* Bugfixes

'''0.6.0'''
* Navigation bar shows scroll location of q/you/notable
  posts and allows jumping to posts
* Notable navigation controls in baker window and board list
* Persistent Image Blacklist (AKA Nope Button)
* Many bugfixes

'''0.5.2'''
* Fixes bread list table population bug

'''0.5.0'''
* Option to show Q/(YOU)/Own Post navigation controls in the boardlist
* Option to hide Notable nomination button
* List of research breads
* BakerTools settings are now saved in local storage

'''0.4.0'''
* Option to blur images until hover
* Adds a "Notable Nomination" button to posts that opens the Quick Reply
  box and prefills it with a BAKER NOTABLE Template
* Add Q Post navigation links to the Baker Window
* Add (You) navigation links to the Baker Window
* Add own post navigation links to the Baker Window
* Cleaned up baker window design

* More code cleanup and linting changes

'''0.3.0'''
* Highlights Q Posts with white BG -> DARK TO LIGHT!
* Highlights Q posts in mentions (I.E. posts that get (YOU)'ed)
* Highlights links to Q Posts

* Refactored code into classes for easier maint.

'''0.2.0'''
* Highlight pb links
* Thread stats overlay with
    * color coded reply count that goes from green to red as bread ages
    * UID Count
    * Jump To Bottom Link
    * Jump To Bottom Top link

'''0.1.0'''
Initial release:
* Highlight notables and nominators
* Filter to only show notables and nominators
* Create notables post

Version History:
https://pastebin.com/6XuDuHYu 0.7.0
https://pastebin.com/YTSSmH7t 0.6.0
https://pastebin.com/mPVxr7Lz 0.5.2
https://pastebin.com/nEhm7yyY 0.5.1
https://pastebin.com/i9sF0Rd3 0.4.0
https://pastebin.com/kz9LrcE9 0.3.0
https://pastebin.com/4aEFsPwK 0.2.0
https://pastebin.com/eNmTtzdi 0.1.0
*/
(function($) {
"use strict";

/* globals $, board_name */
/* exported 8kun */

/**
 * Functions and vars related to EightKun functionality
 */
class EightKun {
  /**
   * Get reply links in post
   * @param {Element} post div.post
   * @return {JQuery}
   */
  static getReplyLinksFromPost(post) {
    return $(post).find(EightKun.REPLY_SELECTOR)
        .filter(function(idx, link) {
          return $(link).text().match(EightKun.REPLY_SHORTLINK_REGEX);
        });
  }

  /**
   * Get the post number that is being replied to
   * @param {Anchor} link
   * @return {string}
   */
  static getPostNumberFromReplyLink(link) {
    return $(link).text()
        .match(EightKun.REPLY_SHORTLINK_REGEX)[1];
  }

  /**
   * Get time of post
   * @param {Element} post div.post
   * @return {number} post time in unixtime
   */
  static getPostTime(post) {
    return $(post).find('.intro time').attr('unixtime');
  }

  /**
   * Get date of post
   * @param {Element} post div.post
   * @return {number} post time in unixtime
   */
  static getPostDateTime(post) {
    return $(post).find('.intro time').attr('datetime');
  }

  /**
   * Get poster id of provided post
   * @param {Element} post div.post
   * @return {string} id of poster
   */
  static getPosterId(post) {
    return $(post).find('p > span.poster_id').first().text();
  }

  /**
   * Get name from post
   * @param {Element} post div.post
   * @return {string} name of post
   */
  static getPostName(post) {
    return $(post).find('.intro > label > .name').text();
  }

  /**
   * Get trip from post
   * @param {Element} post div.post
   * @return {string} trip of post
   */
  static getPostTrip(post) {
    return $(post).find('.intro .trip').text();
  }

  /**
   * Get the opening post of the thread
   * @return {Element} div.post
   */
  static getOpPost() {
    return $(EightKun.OP_POST_SELECTOR);
  }

  /**
   * Get poster id of OP
   * @return {number} poster id
   */
  static getOpPosterId() {
    return EightKun.getPosterId(EightKun.getOpPost());
  }

  /**
   * Is the post made by op?
   * @param {Element} post div.post
   * @return {boolean} true if op's post
   */
  static isPostFromOp(post) {
    return EightKun.getPosterId(post) === EightKun.getOpPosterId();
  }

  /**
   * Get the thread id
   * @return {number} id of thread
   */
  static getThreadId() {
    return $('.thread').get(0).id.split('_')[1];
  }

  /**
   * Use 8kun hide function on post
   * @param {Element} post div.post
   */
  static hidePost(post) {
    // TODO: implement it and use in spam and blacklist
  }

  /**
   * Get current board
   * @return {string}
   */
  static getCurrentBoard() {
    /* eslint-disable camelcase */
    return board_name;
  }

  /**
   * Get current board
   * @param {Element} post div.post
   * @return {number} Number of the post
   */
  static getPostNumber(post) {
    return post.id.split('_')[1];
  }

}
EightKun.POST_SELECTOR = 'div.post';
EightKun.POST_REPLY_SELECTOR = 'div.post.reply';
EightKun.OP_POST_SELECTOR = 'div.post.op';
EightKun.POST_BODY_SELECTOR = '.body';
EightKun.POST_MODIFIED_SELECTOR = '.post_modified';
EightKun.NEW_POST_EVENT = 'new_post';
EightKun.OP_SUBJECT_SELECTOR = '.post.op > p > label > span.subject';
EightKun.REPLY_SELECTOR = 'div.body:first a:not([rel="nofollow"])';
EightKun.REPLY_SHORTLINK_REGEX = /^>>(\d+)$/;
EightKun.REPLY_REGEX = /highlightReply\('(.+?)'/;


/**
 * Wrapper for 8kun active_page variable to determine the type of
 * page the user is on.
 */
class ActivePage {
  /**
   * Are we currently on the thread index page?
   * @return {boolean} True if on index
   */
  static isIndex() {
    return window.active_page == ActivePage.Index;
  }

  /**
   * Are we currently on the thread catalog page?
   * @return {boolean} True if on catalog
   */
  static isCatalog() {
    return window.active_page == ActivePage.Catalog;
  }

  /**
   * Are we on a thread page?
   * @return {boolean} True if on thread
   */
  static isThread() {
    return window.active_page == ActivePage.Thread;
  }
}
ActivePage.Index = 'index';
ActivePage.Catalog = 'catalog';
ActivePage.Thread = 'thread';


/* globals $ */
/* exported ColorPicker */

/**
 * A color picker control that saves to localStorage
 */
class ColorPicker {
  /**
   * Construct color picker
   *
   * @param {string} label The label for the control
   * @param {string} title Mouseover title
   * @param {string} setting localStorage setting name
   * @param {string} defaultValue the default color when setting is missing
   * @param {Function} changeHandler handler for value changes. Passes color
   */
  constructor(label, title, setting, defaultValue, changeHandler) {
    this.styleId = 'bakertools-colorpickers-styles';
    this.class = 'bakertools-colorpicker';
    this.labelClass = 'bakertools-colorpicker-label';
    this.inputClass = 'bakertools-colorpicker-input';
    this.resetButtonClass = 'bakertools-colorpicker-reset';
    this.changeHandler = changeHandler;

    this.label = label;
    this.title = title;
    this.setting = setting;
    this.defaultValue = defaultValue;
    this.strippedName = label.replace(/(\s|\(|\)|'|"|:)/g, '');
    this.defaultValue = defaultValue;

    this._createStyles();
    this._createElement();
  }

  /**
   * Create the HTML Element
   */
  _createElement() {
    this.element = $(`
    <div class='${this.class}'>
      <label class='${this.labelClass}'
        for="${this.strippedName}" title="${this.title}" >
        ${this.label}:
      </label>
    </div>
    `).get(0);

    this.input = $(`
    <input type="color" class='${this.inputClass}'
        id="${this.strippedName}" title="${this.title}" />
    `).get(0);
    $(this.element).append(this.input);

    $(this.input).change(function(e) {
      this.setColor(this.input.value);
    }.bind(this));

    this.reset = $(`
    <button class='${this.resetButtonClass}' title="Reset to Default">
      <i class="fa fa-undo"></i>
    </button>
    `).get(0);
    $(this.element).append(this.reset);

    $(this.reset).click(function(e) {
      e.preventDefault();
      this.setColor(this.defaultValue);
    }.bind(this));

    this.setColor(localStorage.getItem(this.setting) || this.defaultValue);
  }

  /**
   * Set the color
   * @param {string} color valid css color string
   */
  setColor(color) {
    localStorage.setItem(this.setting, color);
    this.input.value = color;
    this.changeHandler(color);
  }

  /**
   * Get the color
   * @return {string} color
   */
  getColor() {
    return this.input.value;
  }
  /**
   * Create styles for the control
   */
  _createStyles() {
    if ($(`#${this.styleId}`).length) {
      return;
    }
    $('head').append(`
    <style id='${this.styleId}'>
      .${this.class} {
        display: flex;
        align-items: center;
      }

      .${this.class} .${this.labelClass} {
        flex-grow: 1;
      }

      .${this.class} .${this.inputClass} {
        margin-right: .5em;
      }

      .${this.resetButtonClass} {
        padding: 0;
        background-color: Transparent;
        background-repeat: no-repeat;
        border: none;
        cursor: pointer;
        overflow: hidden;
        outline: none;
      }
    </style>
    `);
  }
}

/* global $, debounce */
/**
 * Creates first, prev, next, last navigation controls
 */
class NavigationControl {
  /**
   * Construct navigatio control manager object
   *
   * @param {string} label the label for the control
   * @param {Function} updateFunction Called to get latest data
   * @param {string} updateEventName Called to get latest data
   */
  constructor(label, updateFunction, updateEventName) {
    const strippedName = label.replace(/(\s|\(|\)|'|"|:)/g, '');
    this.styleId = 'bakertools-navigationcontrol-styles';
    this.label = label;
    this.updateFunction = updateFunction;
    this.updateEventName = updateEventName;
    this.list = this.updateFunction();

    this.currentIndex = -1;
    this.navigationClass = `bakertools-navcontrol-${strippedName}`;
    this.indexChangeEvent =
      `bakertools-navcontrol-${strippedName}-index-changed`;
    this.currentIndexClass = `${this.navigationClass}-current-index`;
    this.totalClass = `${this.navigationClass}-total`;
    this.goToFirstClass = `${this.navigationClass}-goto-first`;
    this.goToPreviousClass = `${this.navigationClass}-goto-prev`;
    this.goToNextClass = `${this.navigationClass}-goto-next`;
    this.goToLastClass = `${this.navigationClass}-goto-last`;


    this._setupStyles();
    this._createElement();
    this.updateIndexFromCurrentScrollPosition();
    this.updateIndexFromCurrentScrollPosition =
        debounce(this.updateIndexFromCurrentScrollPosition, 500);
    this._setupListeners();
  }

  // TODO: switch to flexbox layout
  /**
   * setup styles for nav control
   */
  _setupStyles() {
    if ($(`#${this.styleId}`).length) {
      return;
    }
    $('head').append(`
    <style id='${this.styleId}'>
    .boardlist .${NavigationControl.containerClass}:before {
      content: '[';
      color: #89A;
    }

    .boardlist .${NavigationControl.containerClass}:after {
      content: ']';
      color: #89A;
    }

    .boardlist .${NavigationControl.containerClass} {
      color: rgb(52, 52, 92);
    }
    </style>
    `);
  }

  /**
   * Create nav element
   */
  _createElement() {
    this.element = $(`
    <span title="Navigate ${this.label}"
        class="${NavigationControl.containerClass}">

        <label for="${this.navigationClass}">${this.label}:</label>
        <span class="${this.navigationClass}
                ${NavigationControl.navigationControlClass}">

                <i class="fa fa-fast-backward ${this.goToFirstClass}"></i>
                <i class="fa fa-backward ${this.goToPreviousClass}"></i>

                <span class="${this.currentIndexClass}">
          ${this.currentIndex+1}
        </span>
        of
        <span class="${this.totalClass}">${this.list.length}</span>

        <i class="fa fa-forward ${this.goToNextClass}"></i>
        <i class="fa fa-fast-forward ${this.goToLastClass}"></i>
      </span>
    </span>
    `).get(0);
  }

  /**
   * Setup button event listeners
   */
  _setupListeners() {
    $(this.element).find('.'+this.goToFirstClass).click(function(e) {
      this.goToFirstPost();
    }.bind(this));

    $(this.element).find('.'+this.goToPreviousClass).click(function(e) {
      this.goToPreviousPost();
    }.bind(this));

    $(this.element).find('.'+this.goToNextClass).click(function(e) {
      this.goToNextPost();
    }.bind(this));

    $(this.element).find('.'+this.goToLastClass).click(function(e) {
      this.goToLastPost();
    }.bind(this));

    $(document).on(this.indexChangeEvent, function(e, index) {
      if (this.currentIndex == index) return;
      this._setCurrentIndex(index);
    }.bind(this));

    $(document).on(this.updateEventName, function() {
      this.list = this.updateFunction();
      $(this.element).find(`.${this.totalClass}`).text(this.list.length);
    }.bind(this));

    $(document).scroll(this.updateIndexFromCurrentScrollPosition.bind(this));
  }

  /**
   * Determine the current index based on scroll position
   */
  updateIndexFromCurrentScrollPosition() {
    for (let i = 0; i < this.list.length; ++i) {
      const post = this.list[i];
      const boundingRect = post.getBoundingClientRect();

      const postTopAboveBottomOfScreen = boundingRect.top < window.innerHeight;
      const postBottomBelowTopOfScreen = boundingRect.bottom > 0;
      const currentPostIsInViewport = postTopAboveBottomOfScreen &&
        postBottomBelowTopOfScreen;

      if (currentPostIsInViewport) {
        this._setCurrentIndex(i);
        break;
      }

      const isFirstPost = i === 0;
      const isBeforeFirstNotable = isFirstPost && !postTopAboveBottomOfScreen;
      if (isBeforeFirstNotable) {
        this._setCurrentIndex(-1);
        break;
      }

      const isLastPost = i === (this.list.length - 1);
      const isPastLastNotable = isLastPost && !postBottomBelowTopOfScreen;
      if (isPastLastNotable) {
        this._setCurrentIndex(i + .5);
        break;
      }

      const nextPost = this.list[i+1];
      const nextPostBounds = nextPost.getBoundingClientRect();
      const nextPostIsBelowBottomOfScreen =
        nextPostBounds.top >= window.innerHeight;
      const inBetweenPosts = !postBottomBelowTopOfScreen &&
        nextPostIsBelowBottomOfScreen;
      if (inBetweenPosts) {
        this._setCurrentIndex(i + .5);
        break;
      }
    }
  }

  /**
   * Scroll to first post
   */
  goToFirstPost() {
    if (!this.list.length) {
      return;
    }
    this._setCurrentIndex(0);
    this.scrollToCurrentPost();
  }

  /**
   * Scroll to next navigated post
   */
  goToPreviousPost() {
    if (!this.list.length) {
      return;
    }
    if (this.currentIndex <= 0) {
      this._setCurrentIndex(this.list.length - 1);
    } else {
      this._setCurrentIndex(Math.ceil(this.currentIndex) - 1);
    }
    this.scrollToCurrentPost();
  }
  /**
   * Scroll to next navigated post
   */
  goToNextPost() {
    if (!this.list.length) {
      return;
    }
    const lastPostIndex = this.list.length - 1;
    if (this.currentIndex >= lastPostIndex) {
      this._setCurrentIndex(0);
    } else {
      this._setCurrentIndex(Math.floor(this.currentIndex) + 1);
    }
    this.scrollToCurrentPost();
  }

  /**
   * Scroll the last  post in this bread into view
   */
  goToLastPost() {
    if (!this.list.length) {
      return;
    }
    const numPosts = this.list.length;
    this._setCurrentIndex(numPosts - 1);
    this.scrollToCurrentPost();
  }

  /**
   * Scrolls the current selected  post into view
   */
  scrollToCurrentPost() {
    const post = this.list[this.currentIndex];
    $(post).get(0).scrollIntoView();

    // Trigger events for other views of this data
    $(document).trigger(this.indexChangeEvent,
        this.currentIndex);

    window.scrollBy(0, -20);
  }

  /**
   * Set internal index var and UI
   * @param {number} index
   */
  _setCurrentIndex(index) {
    this.currentIndex = index;
    this._setCurrentIndexControlValue(index + 1);
  }

  /**
   * Sets the value of the current index in the UI
   * @param {number} val
   */
  _setCurrentIndexControlValue(val) {
    $('.'+this.currentIndexClass).text(val);
  }
}
NavigationControl.containerClass = `bakertools-navcontrol-container`;
NavigationControl.navigationControlClass = 'bakertools-navigation-control';

/* global EightKun, $, NotableHighlighter */
/**
* Wrapper for a post nominated as notable
*/
class NotablePost {
  /**
   * Construct an empty notable post object
   */
  constructor() {
    this.element = null;
    this.postNumber = null;
    this.description = '[DESCRIPTION]';
    this.nominatingPosts = [];
  }

  /**
   * Create a notable post from a nominating post
   *
   * @param {Element} nominatingPost A post that is nominating a notable
   * @return {NotablePost} a Notable post or NullNotablePost if it fails
   */
  static fromNominatingPost(nominatingPost) {
    const notables = [];
    EightKun.getReplyLinksFromPost(nominatingPost)
        .each(function(idx, link) {
          const postNumber = EightKun.getPostNumberFromReplyLink(link);
          if (!NotablePost.findNotableByPostNumber(postNumber)) {
            const notable = new NotablePost();

            const notablePostElement = $(`#reply_${postNumber}`).get(0);
            if (notablePostElement) {
              notable.setElement(notablePostElement);
            } else {
              // TODO: set pb description
              // get the json from the post number
              notable.postNumber = postNumber;
            }
            notable.addNominatingPost(nominatingPost);

            NotablePost.addToListOfNotables(notable);
            notables.push(notable);

            if (notable.element) { // Not pb will need to figure something out
              $(document).trigger(NotablePost.NEW_NOTABLE_POST_EVENT,
                  notable.element);
            }
          }
        });
    return notables;
  }

  /**
   * Add notable to list, and sort list
   * @param {NotablePost} notable
   */
  static addToListOfNotables(notable) {
    NotablePost._notables.push(notable);
    NotablePost._notables.sort(function(n1, n2) {
      if (n1.postNumber < n2.postNumber) {
        return -1;
      } else if ( n1.postNumber > n2.postNumber) {
        return 1;
      }
      return 0;
    });
  }

  /**
   * Is this a NullNotablePost
   * @return {boolean} false
   */
  isNull() {
    return false;
  }

  /**
   * @return {Array<NotablePost>} Array of the current notables
   */
  static getNotables() {
    return NotablePost._notables;
  }

  /**
   * Get notable posts as regular 8kun div.post
   * @return {Array} of div.post
   */
  static getNotablesAsPosts() {
    return NotablePost._notables
        .filter((n) => n.element !== null)
        .map((n) => n.element);
  }

  /**
   * @arg {number} postNumber The post number of notable
   * @return {NotablePost}
   */
  static findNotableByPostNumber(postNumber) {
    return NotablePost._notables.find((notable) => notable.postNumber ==
      postNumber);
  }

  /**
   * Set the element of the post
   * @arg {Element} element
   */
  setElement(element) {
    this.element = element;
    this._markAsNotable(this.element);
    this.description = element.querySelector('.body')
        .innerText
        .replace(/\n/g, ' ');
    this.postNumber = $(this.element).find('.intro .post_no')
        .text()
        .replace('No.', '');
  }

  /**
   * Get the reply shortlink for the post
   * @return {string}
   */
  shortLink() {
    return '>>' + this.postNumber;
  }

  /**
   * Add a nominator to the notable
   *
   * @param {Element} nominatingPost A .div.post that nominates this post
   */
  addNominatingPost(nominatingPost) {
    this.nominatingPosts.push(nominatingPost);
    this._markAsNominator(nominatingPost);
    this._markNominatorInMentions(nominatingPost);
  }

  /**
   * @arg {Element} nominatorPost .post
   */
  _markAsNominator(nominatorPost) {
    nominatorPost.classList.add(NotableHighlighter.NOMINATOR_CLASS);
  }

  /**
   * @arg {Element} post .post
   */
  _markAsNotable(post) {
    post.classList.add(NotableHighlighter.NOTABLE_CLASS);
  }


  /**
   * Gives links to nominators a special style in notable mentions
   *
   * @param {Element} nominatingPost A .div.post that is nominating this
   *  notable
   */
  _markNominatorInMentions(nominatingPost) {
    if (!this.element) {
      console.info(`Notable post is null - possible pb/lb`);
      return;
    }
    const nominatingPostId = nominatingPost.id.replace('reply_', '');
    $(this.element).find('.mentioned-'+nominatingPostId)
        .addClass(NotableHighlighter.NOMINATOR_CLASS);
  }
}
NotablePost._notables = [];
NotablePost.NULL = null; // NullNotablePost
NotablePost.NEW_NOTABLE_POST_EVENT = 'bakertools-new-notable-post-event';

/* globals EightKun */
/**
 * Research Bread Class
 */
class ResearchBread {
  /**
   * Get an array of post bodies with dough posts filtered out
   * @return {NodeList} of .post elements
   */
  static getPostsWithoutDough() {
    const posts = Array.from(document
        .querySelectorAll(EightKun.POST_SELECTOR));

    const filteredPosts = posts.filter(function(post) {
      return !post.querySelector(EightKun.POST_BODY_SELECTOR)
          .innerText.match(ResearchBread.DOUGH_POSTS_REGEX);
    });

    return filteredPosts;
  }

  /**
   * Determine what the bread number is
   * @return {number} the number of the research bread
   */
  static getBreadNumber() {
    const breadNumberRegex = /#(.+?) /;
    return document.querySelector(EightKun.OP_SUBJECT_SELECTOR)
        .innerText
        .match(breadNumberRegex)[1] || 'COULD NOT FIND BREAD NUMBER';
  }

  /**
   * Find the post with the dough
   * @return {Element} div.post
   */
  static getDoughPost() {
    const posts = Array.from(document
        .querySelectorAll(EightKun.POST_SELECTOR));

    const dough = posts.find(function(post) {
      return post.querySelector(EightKun.POST_BODY_SELECTOR)
          .innerText.toUpperCase().match(ResearchBread.DOUGH_POST_TITLE);
    });
    return dough;
  }
}
ResearchBread.BOARD_NAME = 'qresearch';
ResearchBread.WELCOME_POST_TITLE = 'Welcome To Q Research General';
ResearchBread.ANNOUNCEMENTS_POST_TITLE = 'Global Announcements';
ResearchBread.WAR_ROOM_POST_TITLE = 'War Room';
ResearchBread.ARCHIVES_POST_TITLE = 'QPosts Archives';
ResearchBread.DOUGH_POST_TITLE = 'DOUGH';
ResearchBread.DOUGH_POSTS_REGEX = new RegExp(
    `^(${ResearchBread.WELCOME_POST_TITLE}|` +
    `${ResearchBread.ANNOUNCEMENTS_POST_TITLE}|` +
    `${ResearchBread.WAR_ROOM_POST_TITLE}|` +
    `${ResearchBread.ARCHIVES_POST_TITLE}|` +
    `${ResearchBread.DOUGH_POST_TITLE}).*`);


/* globals $, EightKun, debounce, POST_BACKGROUND_CHANGE_EVENT */
/* exported ScrollbarNavigation */
/**
 * Scrollbar navigation
 */
class ScrollbarNavigation {
  /**
   * Construct a scrollbar nav
   * @param {Array} addPostEvents List of event names that produce posts
   *        to show on scrollbar
   */
  constructor(addPostEvents = []) {
    this.id = 'bakertools-scrollbar-navigation';
    this.showScrollbarNavigationId = 'bakertools-show-scrollbar-nav';
    this.width = '20px';
    this.posts = [];
    this.coordsToPost = new Map();
    this.addPostEvents = addPostEvents;

    this.draw = debounce(this.draw, 80);

    this._setupBakerWindowControls();
    this._setupStyles();
    this._createElement();
    this._readSettings();
    this._setupListeners();
  }

  /**
   * Read settings from localStorage
   */
  _readSettings() {
    let showScrollBar = JSON.parse(localStorage
        .getItem(ScrollbarNavigation.SHOW_SCROLLBAR_NAV));

    showScrollBar = showScrollBar === null ? true : showScrollBar;

    this.showScrollBar(showScrollBar);
  }

  /**
   * Add hide/show option to bakerwindow
   */
  _setupBakerWindowControls() {
    window.bakerTools.mainWindow
        .addOption(`
    <label for="${this.showScrollbarNavigationId}"
      title="Show scrollbar navigation" >
      Show Scrollbar Navigation:
    </label>
    <input type="checkbox" id="${this.showScrollbarNavigationId}"
      title="Show scrollbar navigation" /><br />
    `);
  }

  /**
   * Setup event listeners
   */
  _setupListeners() {
    $('#'+this.showScrollbarNavigationId).change(function(e) {
      this.showScrollBar(e.target.checked);
    }.bind(this));

    $(document).on(EightKun.NEW_POST_EVENT, this.draw.bind(this));
    $(window).on('resize', this.draw.bind(this));
    $(window).on(POST_BACKGROUND_CHANGE_EVENT, this.draw.bind(this));

    $('#'+this.id).click(function(e) {
      const post = this.findFirstPostUnderMouse(e.clientX, e.clientY);
      if (post) {
        $(post).get(0).scrollIntoView();
        window.scrollBy(0, -20);
      }
    }.bind(this));

    $(this.element).mousemove(function(e) {
      const [post, coords] = this.findFirstPostUnderMouse(e.clientX, e.clientY);
      const notOverAPost = !post;
      const hoveringOverADifferentPost = this.hoveringPost &&
          this.hoveringPost != post;

      if (notOverAPost || hoveringOverADifferentPost) {
        this.endHover();
      }
      if (this.hovering) {
        return;
      }

      const top = coords.top;
      if (post) {
        this.postHover(post, top);
      }
    }.bind(this));

    $(this.element).mouseout(this.endHover.bind(this));

    this.addPostEvents.forEach(function(eventName) {
      $(document).on(eventName, function(event, posts) {
        this.addPosts(posts);
      }.bind(this));
    }.bind(this));
  }

  /**
   * Find the first post that is under the mouse
   * @param {number} clientX x location of mouse
   * @param {number} clientY y location of mouse
   * @return {Array} div.post, [top,bottom] or null if not found
   */
  findFirstPostUnderMouse(clientX, clientY) {
    let post = null;
    let coords = null;
    for (const keyValue of this.coordsToPost) {
      coords = keyValue[0];
      // if (clientY >= (top - 10) && clientY <= (bottom+10)) {
      if (clientY >= (coords.top) && clientY <= (coords.bottom)) {
        post = keyValue[1];
        break;
      }
    }
    return [post, coords];
  }

  /**
   * Perform post hover functionality for provided post
   * @param {Element} post div.post
   * @param {number} hoverY y location to hover at
   */
  postHover(post, hoverY) {
    this.hovering = true;
    this.hoveringPost = post;
    const $post = $(post);
    if ($post.is(':visible') &&
        $post.offset().top >= $(window).scrollTop() &&
        $post.offset().top + $post.height() <=
          $(window).scrollTop() + $(window).height()) {
      // post is in view
      $post.addClass('highlighted');
    } else {
      const newPost = $post.clone();
      newPost.find('>.reply, >br').remove();
      newPost.find('a.post_anchor').remove();

      const postNumber = EightKun.getPostNumber(post);
      newPost.attr('id', 'post-hover-' + postNumber)
          .attr('data-board', EightKun.getCurrentBoard())
          .addClass('post-hover')
          .css('border-style', 'solid')
          .css('box-shadow', '1px 1px 1px #999')
          .css('display', 'block')
          .css('position', 'absolute')
          .css('font-style', 'normal')
          .css('z-index', '100')
          .css('left', '0')
          .css('margin-left', '')
          .addClass('reply')
          .addClass('post')
          .appendTo('.thread');

      // shrink expanded images
      newPost.find('div.file img.post-image').css({
        'display': '',
        'opacity': '',
      });
      newPost.find('div.file img.full-image').remove();

      let previewWidth = newPost.outerWidth(true);
      const widthDiff = previewWidth - newPost.width();
      const scrollNavLeft = $(this.element).offset().left;
      let left;

      if (scrollNavLeft < $(document).width() * 0.7) {
        left = scrollNavLeft + $(this.element).width();
        if (left + previewWidth > $(window).width()) {
          newPost.css('width', $(window).width() - left - widthDiff);
        }
      } else {
        if (previewWidth > scrollNavLeft) {
          newPost.css('width', scrollNavLeft - widthDiff);
          previewWidth = scrollNavLeft;
        }
        left = scrollNavLeft - previewWidth;
      }
      newPost.css('left', left);

      const scrollTop = $(window).scrollTop();
      let top = scrollTop + hoverY;

      if (top < scrollTop + 15) {
        top = scrollTop;
      } else if (top > scrollTop + $(window).height() - newPost.height() - 15) {
        top = scrollTop + $(window).height() - newPost.height() - 15;
      }

      if (newPost.height() > $(window).height()) {
        top = scrollTop;
      }
      newPost.css('top', top);
    }
  }

  /**
   * End hovering
   */
  endHover() {
    this.hovering = false;
    if (!this.hoveringPost) {
      return;
    }

    $(this.hoveringPost).removeClass('highlighted');
    if ($(this.hoveringPost).hasClass('hidden')) {
      $(this.hoveringPost).css('display', 'none');
    }
    $('.post-hover').remove();
  }

  /**
   * Show/hide scrollbar
   * @param {boolean} shouldShow Shows if true
   */
  showScrollBar(shouldShow) {
    $('#'+this.showScrollbarNavigationId).prop('checked',
        shouldShow);

    localStorage.setItem(ScrollbarNavigation.SHOW_SCROLLBAR_NAV, shouldShow);

    if (shouldShow) {
      $(`#${this.id}`).show();
    } else {
      $(`#${this.id}`).hide();
    }
  }

  /**
   * Setup styles for canvas
   */
  _setupStyles() {
    $('head').append(`
    <style id='${this.id + '-style'}'>
      #${this.id} {
        position: fixed;
        top: 0;
        right: 0;
        height: 100%;
        width: ${this.width};
        background: #000000;
        background: linear-gradient(
          90deg,
          rgba(0,0,0,1) 0%,
          rgba(92,92,92,1) 50%,
          rgba(0,0,0,1) 100%
        );
      }
    </style>
    `);
  }

  /**
   * Create the canvas
   */
  _createElement() {
    $(document.body).append(`
      <canvas id='${this.id}' width='${this.width}' height='300'>
      </canvas>
    `);
    this.element = $(`#${this.id}`).get(0);
  }

  /**
   * Draw the scrollbar
   */
  draw() {
    const canvas = this.element;
    canvas.height = window.innerHeight;
    const ctx = canvas.getContext('2d');
    if (!ctx) {
      console.info('no ctx - is the element created yet?');
      return;
    }
    ctx.clearRect(0, 0, canvas.width, canvas.height);

    const cachedHeight = $(document).height();
    const scrollHeight = canvas.height;

    this.coordsToPost = new Map();

    let lastCoords = null;
    this.posts.forEach(function(post, index) {
      const color = $(post).css('backgroundColor');
      const postRect = post.getBoundingClientRect();
      const scrollLocationPercentage =
          (window.scrollY + postRect.top) / cachedHeight;
      let drawLocation = scrollLocationPercentage * scrollHeight;

      const overlappingPrevious = lastCoords &&
          drawLocation <= (lastCoords.bottom + 2);
      if (overlappingPrevious) {
        drawLocation = lastCoords.bottom + 4;
      }
      const drawHeight = Math.max(
          (postRect.height / cachedHeight) * scrollHeight,
          5,
      );
      const coords = new ScrollbarCoordinates(drawLocation,
          drawLocation + drawHeight);
      this.coordsToPost.set(coords, post);

      ctx.fillStyle = color;
      ctx.fillRect(0, drawLocation, canvas.width, drawHeight);
      lastCoords = coords;
    }.bind(this));
  }

  /**
   * Add posts to scrollbar
   * @param {Element|Array} post div.post
   */
  addPosts(post) {
    if (Array.isArray(post)) {
      post.forEach((p) => this._addPost(p));
    } else {
      this._addPost(post);
    }
    this._sortPosts();
    this.draw();
  }

  /**
   * Add post to post array if not already included
   * @param {Element} post div.post
   */
  _addPost(post) {
    if (this.posts.includes(post)) {
      return;
    }
    this.posts.push(post);
  }

  /**
   * Sort posts by time
   */
  _sortPosts() {
    this.posts.sort(function(p1, p2) {
      const p1PostTime = EightKun.getPostTime(p1);
      const p2PostTime = EightKun.getPostTime(p2);
      if (p1PostTime < p2PostTime) {
        return -1;
      }
      if (p1PostTime > p2PostTime) {
        return 1;
      }
      return 0;
    });
  }
}
ScrollbarNavigation.SHOW_SCROLLBAR_NAV = 'bakertools-show-scrollbar-nav';

/**
 * Coordinates on the scrollbar
 */
class ScrollbarCoordinates {
  /**
   * Construct coords
   * @param {number} top top of rect
   * @param {number} bottom top of rect
   */
  constructor(top, bottom) {
    this.top = top;
    this.bottom = bottom;
  }
}

/* exported debounce, POST_BACKGROUND_CHANGE_EVENT */
/**
* Returns a function, that, as long as it continues to be invoked, will not
* be triggered. The function will be called after it stops being called for
* N milliseconds. If `immediate` is passed, trigger the function on the
* leading edge, instead of the trailing.
* https://davidwalsh.name/javascript-debounce-function
*
* @param {Function} func
* @param {number} wait
* @param {boolean} immediate
* @return {Function} debounced function
*/
function debounce(func, wait, immediate) {
  let timeout;
  return function(...args) {
    const context = this;
    const later = function() {
      timeout = null;
      if (!immediate) func.apply(context, args);
    };
    const callNow = immediate && !timeout;
    clearTimeout(timeout);
    timeout = setTimeout(later, wait);
    if (callNow) func.apply(context, args);
  };
}

const POST_BACKGROUND_CHANGE_EVENT = 'bakertools-post-background-change';

/* globals $ */
/* exported WindowElement */
/**
 * Class for windows
 */
class WindowElement {
  /**
   * Construct WindowElement
   * @param {string} windowName
   * @param {string} linkText
   */
  constructor(windowName, linkText) {
    this.styleId = 'bakertools-WindowElement-basestyles';
    this.id = `bakertools-${windowName}-window`;
    this.linkText = linkText;
    this.class = 'bakertools-WindowElement';
    this.headerClass = 'bakertools-WindowElement-header';
    this.windowCloseId = `bakertools-${windowName}-WindowElement-close`;
    this.windowCloseClass = `bakertools-WindowElement-close`;
    this.element = null;

    this._createWindowStyles();
    this._createElement();
    this._setupWindowLink();
  }

  /**
   * Create the window element
   */
  _createElement() {
    this.element = document.createElement('div');
    this.element.id = this.id;
    $(this.element).addClass(this.class);

    this.element.innerHTML = `
    <header class="${this.headerClass}">
      <h3>${this.linkText}</h3>
      <a id="${this.windowCloseId}" class='${this.windowCloseClass}'
        href="javascript:void(0)">
        <i class="fa fa-times"></i>
      </a>
    </header>
    `;
    document.body.appendChild(this.element);

    $(this.element).draggable();
    $(this.element).hide();

    $('#'+this.windowCloseId).click(function(e) {
      this.hide();
    }.bind(this));
  }

  /**
   * Create CSS styles needed by the window
   */
  _createWindowStyles() {
    if ($('#' + this.styleId).length) {
      return;
    }
    $('head').append(`
      <style id='${this.styleId}'>
      .${this.class} {
        width: 300px;
        background-color: rgb(214, 218, 240);
        position: fixed;
        z-index: 100;
        float: right;
        right:28.25px;
        border: 1px solid;
      }

      .${this.class} .${this.headerClass} {
        background: #98E;
        border: solid 1px;
        text-align: center;
        margin: 0px;
      }

      .${this.class} .${this.headerClass} h3 {
        margin: 0;
      }

      .${this.class} .${this.windowCloseClass} {
        top: 0px;
        right: 0px;
        position: absolute;
        margin-right: 3px;
        font-size: 20px;
      }

      .${this.class} details {
        padding: 5px;
      }

      .${this.class} summary {
        margin: 0 0 8px;
        font-weight: bold;
        border-bottom: solid 2px;
      }
    </style>
    `);
  }

  /**
   * Create link for show/hiding window, placed in boardlist bar
   */
  _setupWindowLink() {
    this.link = document.createElement('a');
    this.link.textContent = `[${this.linkText}]`;
    this.link.style.cssText = 'float: right;';
    this.link.title = this.linkText;
    this.link.href = 'javascript:void(0)';
    document.querySelector('.boardlist').appendChild(this.link);

    this.link.onclick = this.toggle.bind(this);
  }

  /**
   * Setup timeout for updating bread list
   */
  _setupListeners() {
    // window.setTimeout(this.updateBreadList, 1000)
  }

  /**
   * Show the window
   */
  show() {
    $(this.element).css({'top': 15});
    $(this.element).show();
  }

  /**
   * Hide the window
   */
  hide() {
    $(this.element).hide();
  }

  /**
   * Is the window visible?
   * @return {boolean} true if window is visible
   */
  isVisible() {
    return $(this.element).is(':visible');
  }

  /**
   * Toggle visibility of window
   */
  toggle() {
    if (this.isVisible()) {
      this.hide();
    } else {
      this.show();
    }
  }
}

/* exported BakerWindow */
/* global NavigationControl, $, WindowElement */
/**
* Baker Window
*/
class BakerWindow extends WindowElement {
  /**
   * Construct Baker window element, register listeners
   */
  constructor() {
    super('baker', 'Baker Tools');
    this.bakerWindowStyleId = 'bakertools-bakerwindow-style';
    this.bakerWindowOptionsId = 'bakertools-window-options';
    this.bakerWindowColorOptionsId = 'bakertools-window-color-options';
    this.bakerWindowNavigationId = 'bakertools-window-navigation';
    this.bakerWindowBakerId = 'bakertools-window-baker';
    this.bakerWindowBodyId = 'bakertools-bakerwindow-body';

    this._createStyles();
    this._createBody();
  }

  /**
   * Create CSS styles needed by the window
   */
  _createStyles() {
    if ($('#' + this.bakerWindowStyleId).length) {
      return;
    }
    $('head').append(`
    <style id='${this.bakerWindowStyleId}'>
      #${this.id} #${this.bakerWindowNavigationId}
      .${NavigationControl.containerClass} {
        display: inline-block;
        width: 100%;
      }

      #${this.id} #${this.bakerWindowNavigationId}
      .${NavigationControl.navigationControlClass} {
        float: right;
      }
    </style>
    `);
  }

  /**
   * Create the actual window HTML element
   */
  _createBody() {
    $('#'+this.id).append(`
    <form id="${this.bakerWindowBodyId}">
      <details id='${this.bakerWindowOptionsId}' open>
        <summary>Options</summary>
        <details id='${this.bakerWindowColorOptionsId}' open>
          <summary>Colors</summary>
        </details>
      </details>
      <details id='${this.bakerWindowNavigationId}' open>
        <summary>Navigation</summary>
      </details>
      <details id='${this.bakerWindowBakerId}' open>
        <summary>Baker Tools</summary>
      </details>
    </form>
    `);
  }

  /**
   * Add form controls to options section of baker window
   * @arg {Element} htmlContentString form controls
   */
  addOption(htmlContentString) {
    $('#'+this.bakerWindowOptionsId).append(htmlContentString);
  }

  /**
   * Add form controls to color options section of baker window
   * @arg {Element} htmlContentString form controls
   */
  addColorOption(htmlContentString) {
    $('#'+this.bakerWindowColorOptionsId).append(htmlContentString);
  }


  /**
   * Add html elements to the navigation section of the baker window
   * @arg {Element} htmlContentString form controls
   */
  addNavigation(htmlContentString) {
    $('#'+this.bakerWindowNavigationId).append(htmlContentString);
  }

  /**
   * Add html elements to the baker section of the baker window
   * @arg {Element} htmlContentString form controls
   */
  addBaker(htmlContentString) {
    $('#'+this.bakerWindowBakerId).append(htmlContentString);
  }
} // end class BakerWindow

/* global $ */
/**
* Blur images until highlighted
*/
class BlurImages {
  /**
   * Construct blur images object and setup styles
   */
  constructor() {
    this.blurImages = 'bakertools-blur-images';
    this.blurImagesStyleId = 'bakertools-blur-images-style';
    window.bakerTools.mainWindow.addOption(`
      <label for="${this.blurImages}">Blur Images Until Hover</label>
      <input type="checkbox" id="${this.blurImages}"
        title="Blur images until mouse hover" /></br>
    `);

    $('#'+this.blurImages).change(function(e) {
      this.setBlurImages(e.target.checked);
    }.bind(this));

    this._readSettings();
  }

  /**
   * Read settings from localStorage
   */
  _readSettings() {
    this.setBlurImages(JSON.parse(
        localStorage.getItem(
            BlurImages.BLUR_IMAGES_SETTING),
    ));
  }

  /**
   * Set whether or not images are blurred
   * @param {boolean} blurImages if true, blur images
   */
  setBlurImages(blurImages) {
    $('#'+this.blurImages).prop('checked',
        blurImages);

    localStorage.setItem(BlurImages.BLUR_IMAGES_SETTING,
        blurImages);

    if (blurImages) {
      $(`<style id='${this.blurImagesStyleId}' type='text/css'>
          .post-image {
              filter: blur(5px);
              transition: all 233ms;
          }
          .post-image:hover {
              filter: blur(.5px);
              transition: all 89ms;
          }
      </style>`).appendTo('head');
    } else {
      $(`#${this.blurImagesStyleId}`).remove();
    }
  }
}
BlurImages.BLUR_IMAGES_SETTING = 'bakertools-blur-images';



/* globals $, WindowElement, ResearchBread */
/* exported BreadList */
/**
 * Creates a list of breads for navigation comfyness
 */
class BreadList extends WindowElement {
  /**
   * Construct breadlist object
   */
  constructor() {
    super('breadlist', 'Bread List');
    $('#'+this.id).css('height', '400px');
    this.breadListWindowHeaderId = 'bakertools-breadlist-window-header';
    this.breadListWindowCloseId = 'bakertools-breadlist-window-close';
    this.breadListWindowBody = 'bakertools-breadlist-window-body';
    this.breadListTable = 'bakertools-breadlist-table';
    this.lastUpdatedId = 'bakertools-breadlist-lastupdated';

    this._breads = [];
    ResearchBread.BOARD_NAME = 'qresearch';
    this.breadRegex = /(.+)\s+#(\d+):\s+(.+?$)/;
    // /\(.+\) #\(\d+\): \(.+?$\)/;
    this.indexPage = `${window.location.protocol}//${window.location.host}` +
        `/${ResearchBread.BOARD_NAME}/`;

    this._createBody();
    this._setupStyles();
    this.updateBreadList();
    this._setupListeners();
  }

  /**
   * setup table styles
   */
  _setupStyles() {
    // https://stackoverflow.com/questions/21168521/table-fixed-header-and-scrollable-body
    $('head').append(`
    <style id='baketools-breadlist-window-styles'>
      #${this.id} {
        right: 380px;
      }

      #${this.breadListWindowBody} {
        overflow-y: auto;
        height: 365px;
        font-size: .8em;
      }

      #${this.breadListTable} {
        border-collapse: collapse;
        border-spacing: 0px;
      }

      #${this.breadListTable} thead th {
        position: sticky;
        top: 0;
      }

      #${this.breadListTable} th,
      #${this.breadListTable} td {
        border: 1px solid #000;
        border-top: 0;
      }
      #${this.breadListTable} thead th {
        box-shadow: 1px 1px 0 #000;
      }
    </style>
    `);
  }

  /**
   * Create the actual window HTML element
   */
  _createBody() {
    $('#'+this.id).append(`
    <div id='${this.breadListWindowBody}'>
      <table id='${this.breadListTable}'>
        <thead>
          <tr>
            <th>Group</th>
            <th>No.</th>
            <th>Bread</th>
            <th>replies</th>
          </tr>
        </thead>
        <tbody>
        </tbody>
      </table>
    </div>
    <footer>
      Last Updated: <span id="${this.lastUpdatedId}"></span>
    </footer>
    `);
  }

  /**
   * Setup timeout for updating bread list
   */
  _setupListeners() {
    window.setInterval(function(e) {
      this.updateBreadList();
    }.bind(this), 1000 * 60 * 2.5); // 2.5min update
  }

  /**
   * Get the list of breads
   */
  updateBreadList() {
    this.breads = [];

    const promises = [];
    for (let page = 0; page < 3; page++) {
      promises.push(
          $.getJSON(this.indexPage + `${page}.json`,
              this.parseIndex.bind(this)),
      );
    }
    Promise.all(promises).then(function() {
      this.breads.sort(function(a, b) {
        if (a.lastModified < b.lastModified) return -1;
        if (a.lastModified == b.lastModified) return 0;
        if (a.lastModified > b.lastModified) return 1;
      }).reverse();
      this.populateBreadTable();
    }.bind(this));
  }

  /**
   * Parse index json for breads
   * @param {Object} index
   */
  parseIndex(index) {
    if (index && index.threads) {
      index.threads.forEach(function(thread) {
        const op = thread.posts[0];
        const match = op.sub.match(this.breadRegex);

        if (match) {
          const researchGroup = match[1];
          const breadNumber = match[2];
          const breadName = match[3];
          this.breads.push(new Bread(
              ResearchBread.BOARD_NAME,
              researchGroup,
              breadNumber,
              breadName,
              op.replies,
              op.no,
              op.last_modified,
          ));
        }
      }.bind(this)); // Index foreach
    } // if index and index.threads
  }

  /**
   * Populate the bread list table
   */
  populateBreadTable() {
    $(`#${this.breadListTable} tbody`).empty();
    this.breads.forEach(function(bread) {
      this._addBread(bread);
    }.bind(this));

    const lastUpdated = new Date();
    $('#'+this.lastUpdatedId).text(lastUpdated.toLocaleString());
  }

  /**
   * Add bread
   * @param {Bread} bread
   */
  _addBread(bread) {
    $(`#${this.breadListTable} tbody`).append(`
      <tr>
        <td><a href='${bread.url}'>${bread.researchGroup}</a></td>
        <td><a href='${bread.url}'>${bread.researchNumber}</a></td>
        <td><a href='${bread.url}'>${bread.breadName}</a></td>
        <td><a href='${bread.url}'>${bread.replies}</a></td>
      </tr>
    `);
  }
}

/**
 * Represents a research bread
 */
class Bread {
  /**
   * Construct a bread
   *
   * @param {string} boardName
   * @param {string} researchGroup
   * @param {number} researchNumber
   * @param {string} breadName
   * @param {number} replies
   * @param {number} postId
   * @param {number} lastModified
   */
  constructor(boardName, researchGroup, researchNumber, breadName,
      replies, postId, lastModified) {
    this.boardName = boardName;
    this.researchGroup = researchGroup;
    this.researchNumber = researchNumber;
    this.breadName = breadName;
    this.replies = replies;
    this.postId = postId;
    this.lastModified = lastModified;
  }

  /**
   * Get bread url
   *
   * @return {string} url to bread
   */
  get url() {
    return `${window.location.protocol}//${window.location.host}` +
        `/${this.boardName}/res/${this.postId}.html`;
  }
}

/* global $, EightKun */
/**
* Persistent image blacklist (AKA NOPE BUTTON)
*/
class ImageBlacklist {
  /**
   * Construct ImageBlacklist object
   */
  constructor() {
    this.blacklist = [];
    this.styleId = 'bakertools-blacklist-style';
    this.postBlacklistButtonClass = 'bakertools-blacklist-post';
    this.imgBlacklistButtonClass = 'bakertools-blacklist-image';
    this.hidePostBlacklistButtonCheckboxId =
        'bakertools-hide-post-blacklist-buttons';

    this._setupBakerWindowControls();
    this._readSettings();
    this._setupStyles();
    this._setupListeners();
    this.removeBlacklistedImages();
    this.addBlacklistButtons();
  }

  /**
   * Add options to baker window
   */
  _setupBakerWindowControls() {
    window.bakerTools.mainWindow.addOption(`
    <label for="${this.hidePostBlacklistButtonCheckboxId}"
      title="Hide post 'Blacklist' buttons" >
      Hide "Blacklist" buttons
    </label>
    <input type="checkbox" id="${this.hidePostBlacklistButtonCheckboxId}"
      title="Hide post 'Blacklist' buttons" /><br />
    `);
  }


  /**
   * Show or hide the post blacklist buttons
   *
   * @param {boolean} hide
   */
  hidePostBlacklistButton(hide) {
    $('#'+this.hidePostBlacklistButtonCheckboxId).prop('checked',
        hide);

    localStorage.setItem(ImageBlacklist.HIDE_POST_BLACKLIST_BUTTON_SETTING,
        hide);

    const styleId = 'baker-tools-post-blacklist-button-style';
    if (hide) {
      $('head').append(`
        <style id='${styleId}'>
          .${this.postBlacklistButtonClass} {
            display: none;
          }
      `);
    } else {
      $(`#${styleId}`).remove();
    }
  }

  /**
   * Setup styles for blacklist buttons
   */
  _setupStyles() {
    $('head').append(`
      <style id='${this.styleId}'>
        .${this.imgBlacklistButtonClass} {
          padding: 0px;
          background-color: Transparent;
          background-repeat: no-repeat;
          border: none;
          overflow: hidden;
          outline: none;
          cursor: pointer;
        }
      </style>
    `);
  }

  /**
   * Read settings from localstorage
   */
  _readSettings() {
    this.loadBlacklist();

    const hideBlacklistButton = JSON.parse(
        localStorage.getItem(ImageBlacklist.HIDE_POST_BLACKLIST_BUTTON_SETTING),
    );
    this.hidePostBlacklistButton(hideBlacklistButton);
  }

  /**
   * Setup new post event listeners
   */
  _setupListeners() {
    $(document).on(EightKun.NEW_POST_EVENT, function(e, post) {
      this.addBlacklistButtonToPost(post);
    }.bind(this));

    $('#'+this.hidePostBlacklistButtonCheckboxId).change(function(e) {
      this.hidePostBlacklistButton(e.target.checked);
    }.bind(this));
  }

  /**
   * Load blacklist from localStorage
   */
  loadBlacklist() {
    this.blacklist = JSON.parse(localStorage.imageBlacklist || '[]');
  }

  /**
   * Save blacklist to localStorage
   */
  saveBlacklist() {
    localStorage.imageBlacklist = JSON.stringify(this.blacklist);
  }

  /**
   * Add MD5 of an image to the blacklist
   * @param {string} md5 md5 hash of image
   */
  addToBlacklist(md5) {
    if (md5 && -1 === this.blacklist.indexOf(md5)) {
      this.blacklist.push(md5);
    }
  }

  /**
   * Blacklist images in post
   * @param {Element} post
   */
  blacklistPostImages(post) {
    $(post).find(ImageBlacklist.POST_IMG_SELECTOR).each(function(i, postImage) {
      const md5 = postImage.getAttribute('data-md5');
      this.addToBlacklist(md5);
      this.deletePostImage(postImage);
    }.bind(this));
  }

  /**
   * Remove blacklist images on page load
   * @return {number} number of images removed
   */
  removeBlacklistedImages() {
    let removed = 0;
    $(ImageBlacklist.POST_IMG_SELECTOR).each(function(i, postImage) {
      if (-1 !== this.blacklist.indexOf(postImage.getAttribute('data-md5'))) {
        this.deletePostImage(postImage);
        removed += 1;
      }
    }.bind(this));
    return removed;
  }

  /**
   * Add blacklist buttons to post images
   */
  addBlacklistButtons() {
    $('div.post').each(function(i, post) {
      this.addBlacklistButtonToPost(post);
    }.bind(this));
  }

  /**
   * Add blacklist buttons to post
   * @param {Element} post div.post
   */
  addBlacklistButtonToPost(post) {
    const postImageCount = $(post)
        .find(ImageBlacklist.POST_IMG_SELECTOR).length;

    if (postImageCount == 0) {
      return;
    }

    const postBlacklistButton = document.createElement('button');
    $(postBlacklistButton).addClass(this.postBlacklistButtonClass);
    $(postBlacklistButton).append(`
    <i class="fa fa-trash" style="color: crimson;"></i>
    Blacklist all post images`);

    $(postBlacklistButton).click(function(e) {
      e.preventDefault();
      $(post).hide();
      this.blacklistPostImages(post);
      this.saveBlacklist();
    }.bind(this));

    $(post).find(EightKun.POST_MODIFIED_SELECTOR).append(postBlacklistButton);

    $(post).find(ImageBlacklist.POST_IMG_SELECTOR).each(function(i, img) {
      const imgBlacklistButton = document.createElement('button');
      $(imgBlacklistButton).addClass(this.imgBlacklistButtonClass);
      $(imgBlacklistButton).append(`
      <i class="fa fa-trash" style="color: crimson;"
        title="Blacklist image"
        ></i>`);

      $(img)
          .parents('div.file')
          .find('.fileinfo')
          .prepend(imgBlacklistButton);

      $(imgBlacklistButton).click(function(e) {
        e.preventDefault();
        const md5 = img.getAttribute('data-md5');
        this.addToBlacklist(md5);
        this.deletePostImage(img);
        this.saveBlacklist();
      }.bind(this));
    }.bind(this));
  }

  /**
   * Delete post image
   * @param {Element} image
   */
  deletePostImage(image) {
    const imageParent = $(image).parent().parent();
    $(imageParent).append(`
      Image blacklisted
      ${image.getAttribute('data-md5')}
    `);
    $(image).remove();
  }
}
ImageBlacklist.POST_IMG_SELECTOR = 'img.post-image';
ImageBlacklist.HIDE_POST_BLACKLIST_BUTTON_SETTING =
  'bakertools-hide-post-blacklist-button';

/* global $, EightKun */
/**
* Add notable button to posts that opens quick reply
* and populates with a template message
*/
class NominatePostButtons {
  /**
   * Construct NPB object and setup listeners
   */
  constructor() {
    this.nominateButtonClass = 'bakertools-nominate-button';
    this.hidePostNotableButtonCheckboxId = 'bakertools-hide-notables';
    this.bakerNotableHeader = '==BAKER NOTABLE==\n';
    this.notableReasonPlaceholder = '[REASON FOR NOTABLE HERE]';

    $('div.post.reply').each(function(i, post) {
      this._addButtonToPost(post);
    }.bind(this));


    this._setupBakerWindowControls();
    this._setupListeners();
    this._readSettings();
  }

  /**
   * Read settings from localStorage
   */
  _readSettings() {
    this.showNotableNominationButton(JSON.parse(
        localStorage.getItem(
            NominatePostButtons.HIDE_NOMINATE_BUTTON_SETTING),
    ));
  }

  /**
   * Add options to baker window
   */
  _setupBakerWindowControls() {
    window.bakerTools.mainWindow.addOption(`
    <br />
    <label for="${this.hidePostNotableButtonCheckboxId}"
      title="Hide post 'Notable' buttons" >
      Hide "Notable" buttons
    </label>
    <input type="checkbox" id="${this.hidePostNotableButtonCheckboxId}"
      title="Hide post 'Notable' buttons" /><br />
    `);
  }

  /**
   * Setup event listeners
   */
  _setupListeners() {
    $(document).on(EightKun.NEW_POST_EVENT, function(e, post) {
      this._addButtonToPost(post);
    }.bind(this));

    $('#'+this.hidePostNotableButtonCheckboxId).change(function(e) {
      this.showNotableNominationButton(e.target.checked);
    }.bind(this));
  }

  /**
   * Show or hide the notable nomination buttons
   *
   * @param {boolean} showNotableNominationButton
   */
  showNotableNominationButton(showNotableNominationButton) {
    $('#'+this.hidePostNotableButtonCheckboxId).prop('checked',
        showNotableNominationButton);

    localStorage.setItem(NominatePostButtons.HIDE_NOMINATE_BUTTON_SETTING,
        showNotableNominationButton);

    const styleId = 'baker-tools-notable-button-style';
    if (showNotableNominationButton) {
      $('head').append(`
        <style id='${styleId}'>
          .${this.nominateButtonClass} {
            display: none;
          }
      `);
    } else {
      $(`#${styleId}`).remove();
    }
  }


  /**
   * Add button to the provided post
   * @param {Element} post
   */
  _addButtonToPost(post) {
    const button = document.createElement('button');
    $(button).addClass(this.nominateButtonClass);
    $(button).append(`
      <i class="fa fa-star" style="color: goldenrod;"></i>
      Notable`);

    $(button).click(function(e) {
      const postNumber = $(post)
          .find('.intro .post_no')
          .text()
          .replace('No.', '');
      const href = $(post)
          .find('.intro .post_no')
          .get(0).href;

      // 8kun core - adds >>postnumber to- and unhides quickreply
      window.citeReply(postNumber, href);

      const quickReplyBody = $('#quick-reply #body');
      const oldText = quickReplyBody.val();

      quickReplyBody.val(oldText + this.bakerNotableHeader +
        this.notableReasonPlaceholder);

      // Don't ask me why i have to do this, ask CodeMonkeyZ
      // Not sure why citeReply which calls cite needs to set a timeout to
      // replace the body of the quickreply with itself.  We need to combat
      // that here
      // setTimeout(function() {
      //     var tmp = $('#quick-reply textarea[name="body"]').val();
      //     $('#quick-reply textarea[name="body"]').val('').focus().val(tmp);
      //  }, 1);
      // $(window).on('cite', function(e, id, with_link) {
      // TODO: Figure this out
      const self = this;
      setTimeout(function() {
        quickReplyBody.select();
        quickReplyBody.prop('selectionStart',
            oldText.length + self.bakerNotableHeader.length);
      }, 1.2);
    }.bind(this));

    $(post).find(EightKun.POST_MODIFIED_SELECTOR).append(button);
  }
}
NominatePostButtons.HIDE_NOMINATE_BUTTON_SETTING =
    'bakertools-hide-nominate-button';

/* global $, EightKun, ResearchBread,  NotablePost, NavigationControl,
 ColorPicker, POST_BACKGROUND_CHANGE_EVENT */
/**
* Makes notable posts easier to see by highlighting posts that anons nominate
* as notable.
*
* If someone replies to a post and their post contains the word 'notable',
* the replied to post will be considered notable.
*
* Both the notable post and the nominator posts will be highlighted, as well
* as the nominator link in the notable's mentions will be highlighted.
*/
class NotableHighlighter {
  /**
   * Construct notablehighlighter object, find and highlight
   * current notable sand setup listeners
   */
  constructor() {
    this.styleId = 'bakertools-notable-style';
    this.NOMINATING_REGEX = /notable/i;

    this.showOnlyNotablesCheckboxId = 'bakertools-show-only-notable';
    this.createNotablePostButtonId = 'bakertools-create-notable-post';
    this.notableEditorId = 'bakertools-notable-editor';
    this.showNotableNavigationInBoardListId =
        'bakertools-show-notable-nav-in-boardlist';

    this._createStyles();
    this._setupBakerWindowControls();
    this._readSettings();

    this.findNominatedNotables();
    this._setupListeners();
  }

  /**
   * Read settings from local storage
   */
  _readSettings() {
    this.setOnlyShowNotables(JSON.parse(
        localStorage.getItem(
            NotableHighlighter.ONLY_SHOW_NOTABLES_SETTING),
    ));
    this.showNotableNavigationInBoardList(JSON.parse(
        localStorage
            .getItem(NotableHighlighter.SHOW_NOTABLE_NAV_IN_BOARDLIST_SETTING),
    ));
  }

  /**
   * Create styles that determine how notables are highlighted
   */
  _createStyles() {
    const nominatorSelector =
      `${EightKun.POST_REPLY_SELECTOR}.${NotableHighlighter.NOMINATOR_CLASS}`;
    const notableSelector =
      `.thread ${EightKun.POST_REPLY_SELECTOR}` +
      `.${NotableHighlighter.NOTABLE_CLASS}`;
    $('head').append(`
    <style id='${this.styleId}'>
    ${notableSelector} {
      background-color: ${this.notableColor};
    }
    /* less specificity than notable so it has less preference */
    ${nominatorSelector} {
      background-color: ${this.nominatorColor};
    }
    div.post.reply .mentioned .${NotableHighlighter.NOMINATOR_CLASS} {
      color: ${this.nominatorMentionLinkColor};
      font-weight: bold;
      font-size: 1.5em;
    }
    ${notableSelector}.highlighted {
      background: #d6bad0;
    }
    ${nominatorSelector}.highlighted {
      background: #d6bad0;
    }
    </style>
    `);
  }

  /**
   * Add controls to the bakerwindow
   */
  _setupBakerWindowControls() {
    const notablePostsTitle = `Only show, notables, nominators, q, q replied
      posts`;

    const notableColorPicker = new ColorPicker(
        'Notable Post Color',
        'Set background color of notable Posts',
        NotableHighlighter.NOTABLE_COLOR_SETTTING,
        NotableHighlighter.DEFAULT_NOTABLE_COLOR,
        (color) => this.notableColor = color,
    );
    const nominatorColorPicker = new ColorPicker(
        'Nominator Color',
        'Set background color of nominator posts',
        NotableHighlighter.NOMINATOR_COLOR_SETTTING,
        NotableHighlighter.DEFAULT_NOMINATOR_COLOR,
        (color) => this.nominatorColor = color,
    );
    const nominatorMentionLinkColorPicker = new ColorPicker(
        'Nominator Mention Link Color',
        'Set color of nominator mention links',
        NotableHighlighter.NOMINATOR_MENTION_LINK_COLOR_SETTTING,
        NotableHighlighter.DEFAULT_NOMINATOR_MENTION_LINK_COLOR,
        (color) => this.nominatorMentionLinkColor = color,
    );

    window.bakerTools.mainWindow.addColorOption(notableColorPicker.element);
    window.bakerTools.mainWindow.addColorOption(nominatorColorPicker.element);
    window.bakerTools.mainWindow
        .addColorOption(nominatorMentionLinkColorPicker.element);

    window.bakerTools.mainWindow.addOption(`
    <label for="${this.showOnlyNotablesCheckboxId}"
      title="${notablePostsTitle}" >
      Only Show Notable/Nomination Posts:
    </label>
    <input type="checkbox" id="${this.showOnlyNotablesCheckboxId}"
      title="${notablePostsTitle}" />
    `);


    window.bakerTools.mainWindow.addBaker(`
    <button type="button" id="${this.createNotablePostButtonId}"
      title="Create notables list post based on current nominated notables" >
      Create Notable Post
    </button>
    <textarea id="${this.notableEditorId}"></textarea>
    `);

    window.bakerTools.mainWindow
        .addOption(`
    <br /><br />
    <label for="${this.showNotableNavigationInBoardListId}"
      title="Show navigation controls in board list bar" >
      Show Notable Nav in Board List:
    </label>
    <input type="checkbox" id="${this.showNotableNavigationInBoardListId}"
      title="Show navigation controls in board list bar" /><br />
    `);

    this.navigation = new NavigationControl('Notables',
        () => NotablePost.getNotablesAsPosts(),
        NotablePost.NEW_NOTABLE_POST_EVENT);
    window.bakerTools.mainWindow
        .addNavigation(this.navigation.element);

    this.boardListNav = new NavigationControl('Notables',
        () => NotablePost.getNotablesAsPosts(),
        NotablePost.NEW_NOTABLE_POST_EVENT);

    $('.boardlist:first').append(this.boardListNav.element);
    $(this.boardListNav.element).hide();
  }

  /**
   * Set the background color of notable posts
   * @param {string} color A valid css color value.
   *        E.G. ('#ff00ee', 'rgba()' or 'blue')
   */
  set notableColor(color) {
    this._notableColor = color;
    document.getElementById(this.styleId)
        .sheet.cssRules[0].style.background = color;
    $(document).trigger(POST_BACKGROUND_CHANGE_EVENT, color);
  }

  /**
   * Get color for notable post backgrounds
   */
  get notableColor() {
    return this._notableColor;
  }

  /**
   * Set the background color of nominator posts
   * @param {string} color A valid css color value.
   *        E.G. ('#ff00ee', 'rgba()' or 'blue')
   */
  set nominatorColor(color) {
    this._nominatorColor = color;
    document.getElementById(this.styleId)
        .sheet.cssRules[1].style.background = color;
    $(document).trigger(POST_BACKGROUND_CHANGE_EVENT, color);
  }

  /**
   * Get color for notable post backgrounds
   */
  get nominatorColor() {
    return this._nominatorColor;
  }

  /**
   * Set the color of nominator mention links posts
   * @param {string} color A valid css color value.
   *        E.G. ('#ff00ee', 'rgba()' or 'blue')
   */
  set nominatorMentionLinkColor(color) {
    this._nominatorMentionLinkColor = color;
    document.getElementById(this.styleId)
        .sheet.cssRules[2].style.color = color;
  }

  /**
   * Get color for notable post backgrounds
   */
  get nominatorMentionLinkColor() {
    return this._nominatorMentionLinkColor;
  }

  /**
   * Setup listeners for new posts, bakerwindow controls, etc
   */
  _setupListeners() {
    $('#'+this.showOnlyNotablesCheckboxId).change(function(e) {
      this.setOnlyShowNotables(e.target.checked);
    }.bind(this));

    $('#'+this.createNotablePostButtonId).click(function() {
      if ($('#'+this.notableEditorId).val()) {
        if (!confirm(`If you continue, any changes you made will be
            overwritten!`)) {
          return;
        }
      }
      $('#'+this.notableEditorId).val(this.createNotablesPost());
    }.bind(this));

    $(document).on(EightKun.NEW_POST_EVENT, function(e, post) {
      this.checkNewPostsForNotables(post);
    }.bind(this));

    $('#'+this.showNotableNavigationInBoardListId).change(function(e) {
      this.showNotableNavigationInBoardList(e.target.checked);
    }.bind(this));
  }

  /**
   * Show or hide notable nav control in the boardlist
   *
   * @param {boolean} show
   */
  showNotableNavigationInBoardList(show) {
    $('#'+this.showNotableNavigationInBoardListId).prop('checked',
        show);

    localStorage
        .setItem(NotableHighlighter.SHOW_NOTABLE_NAV_IN_BOARDLIST_SETTING,
            show);

    if (show) {
      $(this.boardListNav.element).show();
    } else {
      $(this.boardListNav.element).hide();
    }
  }

  /**
   * Create the notables post for review
   * @return {string} Returns the notable post string
   */
  createNotablesPost() {
    const notables = NotablePost.getNotables();
    const breadNumber = ResearchBread.getBreadNumber();
    let post = `'''#${breadNumber}'''\n\n`;

    notables.forEach(function(notable) {
      post += `${notable.shortLink()} ${notable.description}\n\n`;
    });

    return post;
  }

  /**
   * Checks a post for notable nominations
   * @param {Element} post
   */
  checkNewPostsForNotables(post) {
    $(post).removeAttr('style'); // TODO: try removing

    if (this.isNominatingPost(post)) {
      NotablePost.fromNominatingPost(post);
    }
  }

  /**
   * Finds posts that are being tagged as notable.
   *
   * I.E. Finding any post that has been replied to by a post with the string
   * "notable" in it. Maybe at somepoint this can be smarter.  Q give me some
   * dwave snow white tech!
   *
   * Highlights notable posts in yellow
   * Highlights nominating posts in pink <3
   * Highlights nominating posts in mentions
   * Add nominee count to post
   * @return {Array<NotablePost>}
   */
  findNominatedNotables() {
    const postsWithoutDough = ResearchBread.getPostsWithoutDough();

    // ^s to ignore notables review posts
    const nominatingPosts = postsWithoutDough
        .filter((post) => this.isNominatingPost(post));

    nominatingPosts.forEach(function(nominatingPost) {
      NotablePost.fromNominatingPost(nominatingPost);
    });
    console.log(NotablePost.getNotables());
    return NotablePost.getNotables();
  }

  /**
   * Is the post nominating a notable
   * @arg {Element} post .post
   * @return {boolean} True if post nominates a notable
   */
  isNominatingPost(post) {
    const postContainsNotable = post.textContent
        .search(this.NOMINATING_REGEX) != -1;
    const postIsReplying = EightKun.getReplyLinksFromPost(post).length;
    return postContainsNotable && postIsReplying;
  }

  /**
   * Toggle whether only the notable/nominee posts are shown or not
   * @arg {boolean} onlyShowNotables boolean If true, only show
   *               notables/nominators, else show all
   */
  setOnlyShowNotables(onlyShowNotables) {
    $('#'+this.showOnlyNotablesCheckboxId).prop('checked', onlyShowNotables);

    localStorage.setItem(NotableHighlighter.ONLY_SHOW_NOTABLES_SETTING,
        onlyShowNotables);

    const notableOrNominationPostsSelector =
      `div.post.${NotableHighlighter.NOTABLE_CLASS},
      div.post.${NotableHighlighter.NOMINATOR_CLASS}`;
    const notableOrNominationPostBreaksSelector =
      `div.post.${NotableHighlighter.NOTABLE_CLASS}+br,
      div.post.${NotableHighlighter.NOMINATOR_CLASS}+br`;
    const onlyShowNotablesStyleId = 'bakertools-only-show-notables';

    if (onlyShowNotables) {
      $(`<style id='${onlyShowNotablesStyleId}' type='text/css'>
        div.reply:not(.post-hover),
        div.post+br {
          display: none !important;
          visibility: hidden !important;
        }
        ${notableOrNominationPostsSelector},
        ${notableOrNominationPostBreaksSelector} {
          display: inline-block !important;
          visibility: visible !important;
        }
        </style>`).appendTo('head');
    } else {
      $(`#${onlyShowNotablesStyleId}`).remove();
      // For whatever reason, when the non notable posts are filtered and new
      // posts come through the auto_update, the posts are created with
      // style="display:block" which messes up display.  Remove style attr
      // TODO: can we remove this now that we have !important?
      $(EightKun.POST_SELECTOR).removeAttr('style');
    }
  }

  /**
   * Retrieves only show notable ssetting from localStorage
   * @return {boolean} true if only show notables is turned on
   */
  getOnlyShowNotables() {
    return localStorage
        .getItem(NotableHighlighter.ONLY_SHOW_NOTABLES_SETTING);
  }
}
NotableHighlighter.NOMINATOR_CLASS = 'bakertools-notable-nominator';
NotableHighlighter.NOTABLE_CLASS = 'bakertools-notable';
NotableHighlighter.ONLY_SHOW_NOTABLES_SETTING =
    'bakertools-only-show-notables';
NotableHighlighter.SHOW_NOTABLE_NAV_IN_BOARDLIST_SETTING =
    'bakertools-show-notable-nav-in-boardlist';
NotableHighlighter.NOMINATOR_COLOR_SETTTING =
    'bakertools-nominator-color';
NotableHighlighter.NOTABLE_COLOR_SETTTING =
    'bakertools-notable-color';
NotableHighlighter.NOMINATOR_MENTION_LINK_COLOR_SETTTING =
    'bakertools-nominator-metion-link-color';
NotableHighlighter.DEFAULT_NOTABLE_COLOR = '#E5FFCC';
NotableHighlighter.DEFAULT_NOMINATOR_COLOR = '#ACC395';
NotableHighlighter.DEFAULT_NOMINATOR_MENTION_LINK_COLOR = '#00CC00';

/* globals $, EightKun, debounce */
/* exported PostRateChart */
/**
 * Displays chart of post/min
 */
class PostRateChart {
  /**
   * Construct a postrate chart
   */
  constructor() {
    this.containerClass = 'bakertools-postrate-container';
    this.chartClass = 'bakertools-postrate-chart';
    this.rateClass = 'bakertools-postrate-rate';
    this.styleId = 'bakertools-postrate-style';
    this.hidePostRateChartId = 'bakertools-postrate-hide-postrate';
    this.numberOfPostsForAverage = 10;
    this.numberOfDataPointsShownOnChart = 10;
    this.postTimes = [];
    this.postsPerMinuteHistory = [];
    this._setupStyles();
    this._setupBakerWindowControls();
    this._createElement();
    this._getExistingPostRates();
    this._setupListeners();
    this.draw();
    this.draw = debounce(this.draw, 1000 *2);
    this._readSettings();
  }

  /**
   * Read settings from local storage
   */
  _readSettings() {
    const hidePostRate = JSON.parse(localStorage
        .getItem(PostRateChart.HIDE_POSTRATE_SETTING));

    this.showPostRateChart(!hidePostRate);
  }

  /**
   * Setup chart styles
   */
  _setupStyles() {
    $('head').append(`
    <style id='${this.styleId}'>
    .${this.containerClass} {
      height: 20px;
      padding: 0;
      color: rgb(52, 52, 92);
    }

    .${this.chartClass} {
      border: 1px solid;
      vertical-align: middle;
      padding: 1px;
    }

    .boardlist .${this.containerClass}:before {
      content: '[';
      color: #89A;
    }

    .boardlist .${this.containerClass}:after {
      content: ']';
      color: #89A;
    }
    `);
  }

  /**
   * Add controls to the bakerwindow
   */
  _setupBakerWindowControls() {
    window.bakerTools.mainWindow.addOption(`
    <label for="${this.hidePostRateChartId}"
      title="Hide the postrate chart in boardlist" >
      Hide Post/Min Chart:
    </label>
    <input type="checkbox" id="${this.hidePostRateChartId}"
      title="Hide the postrate chart in boardlist" />
    `);
  }


  /**
   * Setup listener to record post times
   */
  _setupListeners() {
    $(document).on(EightKun.NEW_POST_EVENT, function(idx, post) {
      this._addDataPointFromPost(post);
      this.draw();
    }.bind(this));

    $('#'+this.hidePostRateChartId).change(function(e) {
      this.showPostRateChart(!e.target.checked);
    }.bind(this));
  }

  /**
   * Show or hide post rate chart in the boardlist
   *
   * @param {boolean} show
   */
  showPostRateChart(show) {
    $('#'+this.hidePostRateChartId).prop('checked',
        !show);

    localStorage
        .setItem(PostRateChart.HIDE_POSTRATE_SETTING,
            !show);

    if (show) {
      $(this.element).show();
    } else {
      $(this.element).hide();
    }
  }

  /**
   * Create the canvas element
   */
  _createElement() {
    this.element = $(`
    <span class='${this.containerClass}'>
      Post Rate: <span class='${this.rateClass}'>0</span> posts/min
      <canvas class='${this.chartClass}'></canvas>
    </span>`,
    ).get(0);

    $(this.element).appendTo('div.boardlist:not(.bottom)');

    this.canvas = $(this.element).find('canvas').get(0);

    this.canvas.height = 10;
    this.canvas.width = 100;
  }

  /**
   * Collect post rate data on posts at page load
   */
  _getExistingPostRates() {
    $('div.post').each(function(idx, post) {
      this._addDataPointFromPost(post);
    }.bind(this));
  }

  /**
   * Add a data point (aka the time a post was made)
   * @param {Element} post div.post
   */
  _addDataPointFromPost(post) {
    this.postTimes.push(EightKun.getPostTime(post));
    if (this._isEnoughDataToAverage()) {
      this._recordPostPerMinute();
    }
  }

  /**
   * Return true if theres enough data to perform averaging
   * @return {boolean} true if enough data
   */
  _isEnoughDataToAverage() {
    return this.postTimes.length > (this.numberOfPostsForAverage + 1);
  }

  /**
   * Record post per minute with the current set of post times
   * Calc is done with the last ${this.numberOfPostsForAverage} post times
   */
  _recordPostPerMinute() {
    const startPostIndex =
      this.postTimes.length - this.numberOfPostsForAverage - 1;
    const endPostIndex = this.postTimes.length - 1;
    const startPostTime = this.postTimes[startPostIndex];
    const endPostTime = this.postTimes[endPostIndex];

    const postsPerMinute =
        this.numberOfPostsForAverage / ((endPostTime - startPostTime) / 60);
    this.postsPerMinuteHistory.push(postsPerMinute);
  }

  /**
   * Draw the post rate chart
   */
  draw() {
    if (!this.postsPerMinuteHistory.length) {
      return;
    }

    const canvas = this.canvas;
    const ctx = canvas.getContext('2d');

    this._setPostRateText();

    const normalizedPostPerMinutes = this._normalizePostPerMinutes();

    ctx.clearRect(0, 0, canvas.width, canvas.height);
    ctx.strokeStyle = $('div.boardlist a').css('color');
    ctx.beginPath();

    let x = 0;
    let y = canvas.height * normalizedPostPerMinutes[0];

    ctx.moveTo(x, y);
    normalizedPostPerMinutes.slice(1).forEach(function(ppm, i) {
      x = (i+1) * (canvas.width / this.numberOfDataPointsShownOnChart);
      y = canvas.height * ppm;
      ctx.lineTo(x, y);
    }.bind(this));
    ctx.stroke();
    ctx.closePath();
  }

  /**
   * Set the text label of current PPM
   */
  _setPostRateText() {
    const lastIndex = this.postsPerMinuteHistory.length-1;
    const currentPPM =
      this.postsPerMinuteHistory[lastIndex].toFixed(2);
    $(`.${this.rateClass}`).text(currentPPM);
  }

  /**
   * Normalize the data points to be within 0-1 range.
   * Slice the array to only contain the currently drawn slice
   * @return {Array}
   */
  _normalizePostPerMinutes() {
    const slicedArray =
      this.postsPerMinuteHistory.slice(-this.numberOfDataPointsShownOnChart);
    const maxPPM = Math.max(...slicedArray);
    const minPPM = Math.min(...slicedArray);
    const range = maxPPM - minPPM;
    return slicedArray.map(function(ppm) {
      return (ppm - minPPM) / range;
    });
  }
}
PostRateChart.HIDE_POSTRATE_SETTING =
  'bakertools-hide-postrate-chart';

/* global $, EightKun, ColorPicker */
/* exported PreviousBreadHighlighter */
/**
* Highlights previous bread post links
*/
class PreviousBreadHighlighter {
  /**
   * Construct pb highlighter object, setup listeners
   */
  constructor() {
    this.styleId = 'bakertools-previous-bread-styles';
    this.previousBreadClass = 'bakertools-PreviousBread';
    this.newerBreadClass = 'bakertools-NewBread';
    this._linkSelector = 'div.body > p.body-line.ltr > a';

    this._setupStyles();
    this._setupBakerWindowControls();

    const links = $(this._linkSelector).filter('[onClick]');
    links.each(function(index, link) {
      this.markLinkIfPreviousBread(link);
    }.bind(this));

    this._setupListeners();
  }

  /**
   * Setup color picker controls
   */
  _setupBakerWindowControls() {
    const colorPicker = new ColorPicker(
        'Previous Bread Link Color',
        'Set the color of links to previous breads',
        PreviousBreadHighlighter.PREVIOUS_BREAD_LINK_COLOR_SETTING,
        PreviousBreadHighlighter.DEFAULT_PREVIOUS_BREAD_LINK_COLOR,
        (color) => this.previousBreadLinkColor = color,
    );

    window.bakerTools.mainWindow.addColorOption(colorPicker.element);

    const newerBreadColorPicker = new ColorPicker(
        'Newer Bread Link Color',
        'Set the color of links to newer breads',
        PreviousBreadHighlighter.NEWER_BREAD_LINK_COLOR_SETTING,
        PreviousBreadHighlighter.DEFAULT_NEWER_BREAD_LINK_COLOR,
        (color) => this.newerBreadLinkColor = color,
    );

    window.bakerTools.mainWindow.addColorOption(newerBreadColorPicker.element);
  }

  /**
   * Set the  color of pb links
   * @param {string} color A valid css color value.
   *        E.G. ('#ff00ee', 'rgba()' or 'blue')
   */
  set previousBreadLinkColor(color) {
    this._previousBreadLinkColor = color;
    document.getElementById(this.styleId)
        .sheet.cssRules[0].style.color = color;
  }

  /**
   * Get color of pb links
   */
  get previousBreadLinkColor() {
    return this._previousBreadLinkColor;
  }

  /**
   * Set the  color of nb links
   * @param {string} color A valid css color value.
   *        E.G. ('#ff00ee', 'rgba()' or 'blue')
   */
  set newerBreadLinkColor(color) {
    this._newerBreadLinkColor = color;
    document.getElementById(this.styleId)
        .sheet.cssRules[2].style.color = color;
  }

  /**
   * Get color of nb links
   */
  get newerBreadLinkColor() {
    return this._newerBreadLinkColor;
  }

  /**
   * Setup styles for pb links
   */
  _setupStyles() {
    $('head').append(`
    <style id='${this.styleId}'>
    ${EightKun.POST_REPLY_SELECTOR} div.body a.${this.previousBreadClass} {
        color: ${this.previousBreadLinkColor};
    }
    a.${this.previousBreadClass}::after {
      content: " (pb)";
    }

    ${EightKun.POST_REPLY_SELECTOR} div.body a.${this.newerBreadClass} {
        color: ${this.newerBreadLinkColor};
    }
    a.${this.newerBreadClass}::after {
      content: " (nb)";
    }
    </style>
    `);
  }

  /**
   * Setup listeners for pb highlighting
   */
  _setupListeners() {
    $(document).on(EightKun.NEW_POST_EVENT, function(e, post) {
      $(post).find(this._linkSelector)
          .each((index, link) => this.markLinkIfPreviousBread(link));
    }.bind(this));
  }

  /**
   * Marks the link if it is pb
   *
   * @param {Anchor} link
   */
  markLinkIfPreviousBread(link) {
    const currentBreadNumber = document.location.pathname
        .split('/')
        .slice(-1)[0]
        .split('.')[0];
    const linkBreadNumber = link.href.split('/')
        .slice(-1)[0]
        .split('#')[0]
        .split('.')[0];

    const isAReplyLink = $(link)
        .attr('onclick')
        .search(EightKun.REPLY_REGEX) != 1;
    if (isAReplyLink &&
        currentBreadNumber > linkBreadNumber) {
      $(link).addClass(this.previousBreadClass);
    } else if (isAReplyLink &&
      currentBreadNumber < linkBreadNumber) {
      $(link).addClass(this.newerBreadClass);
    }
  }
}
PreviousBreadHighlighter.PREVIOUS_BREAD_LINK_COLOR_SETTING =
  'bakertools-previous-bread-link-color';
PreviousBreadHighlighter.DEFAULT_PREVIOUS_BREAD_LINK_COLOR =
  '#0000CC';
PreviousBreadHighlighter.NEWER_BREAD_LINK_COLOR_SETTING =
  'bakertools-newer-bread-link-color';
PreviousBreadHighlighter.DEFAULT_NEWER_BREAD_LINK_COLOR =
  '#00CC00';

/* global $, EightKun, ResearchBread, NavigationControl,
 ColorPicker, POST_BACKGROUND_CHANGE_EVENT */
/**
* Highlight Q posts, replies to q, q replies.
* Adds navigation to baker window
*/
class QPostHighlighter {
  /**
   * Construct qposthighlighter object and setup listeners
   */
  constructor() {
    this.styleId = 'bakertools-q-style';
    this.qPostClass = 'bakertools-q-post';
    this.qReplyClass = 'bakertools-q-reply';
    this.qMentionClass = 'bakertools-q-mention';
    this.qLinkClass = 'bakertools-q-link';
    this.styleId = 'bakertools-q-styles';
    this._linkSelector = 'div.body > p.body-line.ltr > a';
    this.showQNavigationInBoardListId =
        'bakertools-show-q-nav-in-boardlist';

    this.currentQTripCode = null;

    this._setupStyles();
    this._setupBakerWindowControls();
    this._readSettings();
    this._findQPosts();
    this._setupListeners();
  }

  /**
   * Read settings from localStorage
   */
  _readSettings() {
    this.showQNavigationInBoardList(JSON.parse(
        localStorage
            .getItem(QPostHighlighter.SHOW_Q_NAV_IN_BOARDLIST_SETTING),
    ));
  }

  /**
   * Setup styles for highlighting q posts
   */
  _setupStyles() {
    $('head').append(`
    <style id='${this.styleId}'>
     ${EightKun.POST_REPLY_SELECTOR}.${this.qPostClass} {
      background: ${this.qPostColor};
      display: inline-block !important;
      visibility: visible !important;
    }

    ${EightKun.POST_REPLY_SELECTOR}.${this.qReplyClass} {
      background: ${this.qYouColor};
      display: inline-block !important;
      visibility: visible !important;
    }

    ${EightKun.POST_REPLY_SELECTOR}.${this.qPostClass}.highlighted {
      background: #d6bad0;
    }

    ${EightKun.POST_REPLY_SELECTOR} .intro .${this.qMentionClass},
    .${this.qLinkClass} {
      padding:1px 3px 1px 3px;
      background-color:black;
      border-radius:8px;
      border:1px solid #bbbbee;
      color:gold;
      background: linear-gradient(300deg, #ff0000, #ff0000, #ff0000, #bbbbbb,
                #4444ff);
      background-size: 800% 800%;

      -webkit-animation: Patriot 5s ease infinite;
      -moz-animation: Patriot 5s ease infinite;
      -o-animation: Patriot 5s ease infinite;
      animation: Patriot 5s ease infinite;
      -webkit-text-fill-color: transparent;

      background: -o-linear-gradient(transparent, transparent);
      -webkit-background-clip: text;
    }
    </style>
    `);
  }

  /**
   * Set the background color of q posts
   * @param {string} color A valid css color value.
   *        E.G. ('#ff00ee', 'rgba()' or 'blue')
   */
  set qPostColor(color) {
    this._qPostColor = color;
    document.getElementById(this.styleId)
        .sheet.cssRules[0].style.background = color;
    $(document).trigger(POST_BACKGROUND_CHANGE_EVENT, color);
  }

  /**
   * Get color for q post backgrounds
   */
  get qPostColor() {
    return this._qPostColor;
  }

  /**
   * Set the background color of q posts
   * @param {string} color A valid css color value.
   *        E.G. ('#ff00ee', 'rgba()' or 'blue')
   */
  set qYouColor(color) {
    this._qYouColor = color;
    document.getElementById(this.styleId)
        .sheet.cssRules[1].style.background = color;
    $(document).trigger(POST_BACKGROUND_CHANGE_EVENT, color);
  }

  /**
   * Get bg color for posts q replies to
   */
  get qYouColor() {
    return this._qYouColor;
  }

  /**
   * Get Q's current trip code from the bread
   */
  _getCurrentQTripFromBread() {
    const tripCodeMatch = $(EightKun.getOpPost())
        .text()
        .match(/Q's Trip-code: Q (.+?\s)/);

    if (!tripCodeMatch) {
      console.error('Could not find Q\'s tripcode');
      return;
    }
    this.currentQTripCode = tripCodeMatch[1].split(' ')[0];
  }

  /**
   * Find current Q posts in bread
   */
  _findQPosts() {
    const posts = ResearchBread.getPostsWithoutDough();

    $(posts).each(function(i, post) {
      this._doItQ(post);
    }.bind(this));
  }

  /**
   * Check if the post is Q
   * WWG1WGA
   *
   * @param {Element} post a div.post
   */
  _doItQ(post) {
    if (this._markIfQPost(post)) { // Q Post, lets check for q replies
      const qPostNumber = $(post)
          .find('.intro .post_no')
          .text()
          .replace('No.', '');

      const links = $(post)
          .find(this._linkSelector)
          .filter('[onClick]');

      $(links).each(function(i, link) {
        const postNumber = link.href.split('#')[1];
        // Enlightened post
        $(`#reply_${postNumber}`).addClass(this.qReplyClass);

        const metionLinkSelector = `#reply_${postNumber} .intro .mentioned a`;
        $(metionLinkSelector).each(function(i, mentionAnchor) {
          const mentionPostNumber = $(mentionAnchor).text().replace('>>', '');
          if (mentionPostNumber == qPostNumber) {
            $(mentionAnchor).addClass(this.qMentionClass);
          }
        }.bind(this));
      }.bind(this));
    } else { // Not Q, but lets check if this post replies to Q
      const links = $(post).find(this._linkSelector).filter('[onClick]');

      $(links).each(function(i, link) {
        const postNumber = link.href.split('#')[1];
        const replyPost = document.querySelector(`#reply_${postNumber}`);
        // TODO: need to handle pb posts
        if (this.isQ(replyPost)) {
          $(link).addClass(this.qLinkClass);
        }
      }.bind(this));
    }
  }

  /**
   * @arg {Element} post div.post.reply
   * @return {boolean} true if it is a q post
   */
  _markIfQPost(post) {
    let isQ = false;
    if (this.isQ(post)) {
      isQ = true;
      $(post).addClass(this.qPostClass);
      QPostHighlighter.qPosts.push(post);

      $(document).trigger(QPostHighlighter.NEW_Q_POST_EVENT, post);
    }
    return isQ;
  }

  /**
   * Is the post Q?
   * @param {Element} post a div.post.reply
   * @return {boolean} true if the post is Q
   */
  isQ(post) {
    const qTripHistory = QTripCodeHistory.INSTANCE;
    const dateOfPost = new Date(EightKun.getPostDateTime(post));
    const expectedQTripBasedOnDate = qTripHistory.getTripCodeByDate(dateOfPost);
    if (!expectedQTripBasedOnDate) {
      console.info(`Could not find Q trip code for date: ${dateOfPost}`);
      return false;
    }

    return EightKun.getPostTrip(post) == expectedQTripBasedOnDate.tripCode;
  }

  /**
   * Add Q post navigation to bakerwindow
   */
  _setupBakerWindowControls() {
    window.bakerTools.mainWindow
        .addOption(`
    <label for="${this.showQNavigationInBoardListId}"
      title="Show navigation controls in board list bar" >
      Show Q Nav in Board List:
    </label>
    <input type="checkbox" id="${this.showQNavigationInBoardListId}"
      title="Show navigation controls in board list bar" /><br />
    `);

    this.navigation = new NavigationControl('Q Posts',
        () => QPostHighlighter.qPosts, QPostHighlighter.NEW_Q_POST_EVENT);
    window.bakerTools.mainWindow
        .addNavigation(this.navigation.element);

    this.boardListNav = new NavigationControl('Q Posts',
        () => QPostHighlighter.qPosts, QPostHighlighter.NEW_Q_POST_EVENT);

    $('.boardlist:first').append(this.boardListNav.element);
    $(this.boardListNav.element).hide();

    const qColorPicker = new ColorPicker(
        'Q Post Color',
        'Set background color of Q Posts',
        QPostHighlighter.Q_POST_COLOR_SETTING,
        QPostHighlighter.DEFAULT_Q_POST_COLOR,
        (color) => this.qPostColor = color,
    );
    const qYouColorPicker = new ColorPicker(
        'Q (You) Color',
        'Set background color of posts Q Replies to',
        QPostHighlighter.Q_YOU_POST_COLOR_SETTING,
        QPostHighlighter.DEFAULT_Q_YOU_POST_COLOR,
        (color) => this.qYouColor = color,
    );

    window.bakerTools.mainWindow.addColorOption(qColorPicker.element);
    window.bakerTools.mainWindow.addColorOption(qYouColorPicker.element);
  }


  /**
   * Setup listeners for new posts
   */
  _setupListeners() {
    $(document).on(EightKun.NEW_POST_EVENT, function(e, post) {
      this._doItQ(post);
    }.bind(this));

    $('#'+this.showQNavigationInBoardListId).change(function(e) {
      this.showQNavigationInBoardList(e.target.checked);
    }.bind(this));
  }

  /**
   * Show or hide q nav control in the boardlist
   *
   * @param {boolean} showNavInBoardList
   */
  showQNavigationInBoardList(showNavInBoardList) {
    $('#'+this.showQNavigationInBoardListId).prop('checked',
        showNavInBoardList);

    localStorage.setItem(QPostHighlighter.SHOW_Q_NAV_IN_BOARDLIST_SETTING,
        showNavInBoardList);

    if (showNavInBoardList) {
      $(this.boardListNav.element).show();
    } else {
      $(this.boardListNav.element).hide();
    }
  }
}
QPostHighlighter.qPosts = [];
QPostHighlighter.NEW_Q_POST_EVENT = 'bakertools-new-q-post';
QPostHighlighter.SHOW_Q_NAV_IN_BOARDLIST_SETTING =
    'bakertools-show-q-nav-in-boardlist';
QPostHighlighter.Q_YOU_COLOR_SETTING =
    'bakertools-q-you-color';
QPostHighlighter.Q_POST_COLOR_SETTING =
    'bakertools-q-post-color';
QPostHighlighter.DEFAULT_Q_POST_COLOR = '#FFFFCC';
QPostHighlighter.DEFAULT_Q_YOU_POST_COLOR = '#DDDDDD';

/**
 * History of Q's tripcodes and their date ranges
 */
class QTripCodeHistory {
  /**
   * Construct the q trip history
   */
  constructor() {
    // Hat tip to https://8kun.top/qresearch/res/7762733.html#7832643 for Q trip history
    this.history = [
      new QTripCode('!ITPb.qbhqo',
          new Date('2017-11-10 04:07:15Z'), new Date('2017-12-15 06:04:43Z')),
      new QTripCode('!UW.yye1fxo',
          new Date('2017-12-15 06:04:06Z'), new Date('2018-03-24 13:09:02Z')),
      new QTripCode('!xowAT4Z3VQ',
          new Date('2018-03-24 13:09:37Z'), new Date('2018-05-04 20:02:22Z')),
      new QTripCode('!2jsTvXXmXs',
          new Date('2018-05-04 20:01:19Z'), new Date('2018-05-08 23:46:39Z')),
      new QTripCode('!4pRcUA0lBE',
          new Date('2018-05-08 23:47:17Z'), new Date('2018-05-19 22:06:20Z')),
      new QTripCode('!CbboFOtcZs',
          new Date('2018-05-19 22:07:06Z'), new Date('2018-08-05 20:12:52Z')),
      new QTripCode('!A6yxsPKia.',
          new Date('2018-08-05 20:14:24Z'), new Date('2018-08-10 18:24:24Z')),
      new QTripCode('!!mG7VJxZNCI',
          new Date('2018-08-10 18:26:08Z'), new Date('2019-11-25 22:35:45Z')),
      new QTripCode('!!Hs1Jq13jV6',
          new Date('2019-12-02 17:55:59Z'), null),
    ];
  }

  /**
   * Get Q Tripcode by the provided date
   * @param {Date} date
   * @return {QTripCode}
   */
  getTripCodeByDate(date) {
    let returnTripCode = null;
    for (const tripCode of this.history) {
      if (tripCode.isValidForDate(date)) {
        returnTripCode = tripCode;
        break;
      }
    }
    return returnTripCode;
  }

  /**
   * Get Q Tripcode by the current
   * @return {QTripCode}
   */
  getCurrentTripCode() {
    return this.getTripCodeByDate(new Date());
  }
}

/**
 * Represents a Tripcode used by Q and the timeframe
 */
class QTripCode {
  /**
   * Create a new QTripCode
   * @param {string} tripCode
   * @param {DateTime} startDate
   * @param {DateTime} endDate
   */
  constructor(tripCode, startDate, endDate) {
    this.tripCode = tripCode;
    this.startDate = startDate;
    this.isCurrentTrip = false;
    if (!endDate) {
      this.isCurrentTrip = true;
    }
    this.endDate = endDate;
  }

  /**
   * Is this tripcode valid for the provided date?
   * @param {Date} date
   * @return {boolean} true if this trip code is valid for the date
   */
  isValidForDate(date) {
    const dateIsOnOrAfterTripStart = date >= this.startDate;
    const dateIsOnOrBeforeTripEnd = date <= this.endDate;
    return dateIsOnOrAfterTripStart &&
      (this.isCurrentTrip || dateIsOnOrBeforeTripEnd);
  }
}

QTripCodeHistory.INSTANCE = new QTripCodeHistory();

/* globals $, EightKun, ResearchBread */
/* exported SpamFader, NameFagStrategy, HighPostCountFagStrategy,
* FloodFagStrategy, BreadShitterFagStrategy */
// Replies to self all the time
// Replies to no one
/**
* Fade posts that post too fast
*/
class SpamFader {
  /**
   * Construct spamfader
   * @param {Array} spamDetectionStrategies An array of SpamDetectionStrategy's
   */
  constructor(spamDetectionStrategies) {
    this.spamDetectionStrategies = spamDetectionStrategies;
    this.styleId = 'bakertools-spamfader-style';
    this.spamClass = 'bakertools-spamfader-spam';
    this.disableSpamFaderId = 'bakertools-spamfader-disable';
    this.hideSpamBadgesId = 'bakertools-spamfader-hide-spam-badges';
    this._createStyles();
    this._setupBakerWindowControls();
    this._readSettings();
    this._spamFadeExistingPosts();
    this._setupListeners();
  }

  /**
   * Create stylesheets
   */
  _createStyles() {
    $('head').append(`
    <style id='${this.styleId}'>
      div.post.post-hover {
        opacity: 1 !important;
      }
    </style>
    `);
  }

  /**
   * Setup settings UI for spamfading
   */
  _setupBakerWindowControls() {
    window.bakerTools.mainWindow.addOption(`
    <br /><br />
    <label for='${this.disableSpamFaderId}'>Disable SpamFader</label>
    <input type='checkbox' id='${this.disableSpamFaderId}' /><br />

    <label for='${this.hideSpamBadgesId}'>Hide spam badges</label>
    <input type='checkbox' id='${this.hideSpamBadgesId}'/>
    `);
  }

  /**
   * Loop through posts for spam
   */
  _spamFadeExistingPosts() {
    $(EightKun.POST_REPLY_SELECTOR).each(function(i, post) {
      this._detectSpam(post);
    }.bind(this));
  }

  /**
   * Determine if provided post is spam, if so, add spam class
   *
   * @param {Element} post div.post
   */
  _detectSpam(post) {
    const posterStats = SpamFader.getPosterStats(post);
    posterStats.addPost(post);

    if (SpamFader.isMarkedAsNotSpam(posterStats)) {
      return;
    }

    this.spamDetectionStrategies.forEach((sds) => sds.isSpam(post));
    this._takeSpamAction(posterStats);
  }

  /**
   * Performs the spam action against the poster's posts.
   * @param {PosterStats} posterStats
   */
  _takeSpamAction(posterStats) {
    if (!posterStats.isSpam) {
      return;
    }
    if (this.spamAction === SpamFader.FADE) {
      const opacity =
        Math.max(SpamFader.MIN_OPACITY, (1 - posterStats.fadeProgress));

      posterStats.posts.forEach(function(p) {
        $(p).css('opacity', opacity);
        $(p).off('mouseenter mouseleave');
        $(p).hover(function() {
          $(p).animate({opacity: 1.0}, SpamFader.ANIMATION_DURATION);
        }, function() {
          $(p).animate({opacity: opacity}, SpamFader.ANIMATION_DURATION);
        });
      });
    } else if (this.spamAction === SpamFader.HIDE) {
      posterStats.posts.forEach(function(p) {
        EightKun.hidePost(p);
      });
    }
  }

  /**
   * Setup new post listener
   */
  _setupListeners() {
    $(document).on(EightKun.NEW_POST_EVENT, function(e, post) {
      this._detectSpam(post);
    }.bind(this));

    $(`#${this.disableSpamFaderId}`).change(function(e) {
      this.disableSpamFader(e.target.checked);
    }.bind(this));

    $(`#${this.hideSpamBadgesId}`).change(function(e) {
      this.hideSpamBadges(e.target.checked);
    }.bind(this));
  }

  /**
   * Hide the actions of the spamfader.
   * @param {boolean} disable
   */
  disableSpamFader(disable) {
    $('#'+this.disableSpamFaderId).prop('checked', disable);
    localStorage.setItem(SpamFader.DISABLE_SPAM_FADER_SETTING, disable);

    if (disable) {
      $(SpamFader.SPAM_BADGES_SELECTOR).hide();
      $(SpamFader.NOT_SPAM_BUTTON_SELECTOR).hide();
      $(EightKun.POST_REPLY_SELECTOR)
          .css({'opacity': ''})
          .off('mouseenter mouseleave');
    } else {
      $(SpamFader.SPAM_BADGES_SELECTOR).show();
      $(SpamFader.NOT_SPAM_BUTTON_SELECTOR).show();
      SpamFader.posterStats.forEach(this._takeSpamAction.bind(this));
    }
  }

  /**
   * Hide spam badges on posts
   * @param {boolean} hide
   */
  hideSpamBadges(hide) {
    $('#'+this.hideSpamBadgesId).prop('checked', hide);

    localStorage.setItem(SpamFader.HIDE_SPAM_BADGES_SETTING, hide);

    if (hide) {
      $(SpamFader.SPAM_BADGES_SELECTOR).hide();
    } else {
      $(SpamFader.SPAM_BADGES_SELECTOR).show();
    }
  }

  /**
   * Read spamfader settings
   */
  _readSettings() {
    this.spamAction = localStorage[SpamFader.SPAM_ACTION_SETTING] ||
      SpamFader.FADE;

    this.hideSpamBadges(JSON.parse(
        localStorage.getItem(
            SpamFader.HIDE_SPAM_BADGES_SETTING),
    ));

    this.disableSpamFader(JSON.parse(
        localStorage.getItem(
            SpamFader.DISABLE_SPAM_FADER_SETTING),
    ));
  }

  /**
   * Get post stats for post
   * @param {Element} post div.post
   * @return {PosterStats}
   */
  static getPosterStats(post) {
    const posterId = EightKun.getPosterId(post);
    if (!SpamFader.posterStats.has(posterId)) {
      SpamFader.posterStats.set(posterId, new PosterStats(posterId));
    }
    return SpamFader.posterStats.get(posterId);
  }

  /**
   * Adds spam badge to the posts by the poster.
   * Wear them proudly fag!
   *
   * @param {PosterStats} posterStats The posterStats object representing
   *        spam fag
   * @param {string} badge Font-Awesome glyph for badge
   * @param {string} badgeTitle The title describing the badge
   */
  static addSpamBadge(posterStats, badge, badgeTitle) {
    posterStats.posts.forEach(function(post) {
      if (!$(post).find(SpamFader.SPAM_BADGES_SELECTOR).length) {
        SpamFader.createSpamBadgeSection(post);
      }
      const alreadyHasBadge = $(post)
          .find(SpamFader.SPAM_BADGES_SELECTOR)
          .find(`.fa-${badge}`).length;

      if (!alreadyHasBadge) {
        $(post).find(SpamFader.SPAM_BADGES_SELECTOR).append(
            `<i class="fa fa-${badge}" title='${badgeTitle}'></i>`,
        );
      }
    });
  }

  /**
   * Create section for spam badges
   * @param {Element} post div.post
   */
  static createSpamBadgeSection(post) {
    const $postModifiedSection = $(post).find(EightKun.POST_MODIFIED_SELECTOR);
    const button = $(`<button class='${SpamFader.NOT_SPAM_BUTTON_CLASS}'>
        <i class="fa fa-undo" title='Not spam'></i>Not Spam
      </button>
    `);

    button.click(function(e) {
      e.preventDefault();
      SpamFader.markNotSpam(post);
    });

    button.appendTo($postModifiedSection);

    $postModifiedSection.append(`
          <span class='${SpamFader.SPAM_BADGES_CLASS}'>Spam Badges:</span>`);
  }

  /**
   * Mark poster as not spam.
   *
   * @param {Element} post div.post
   */
  static markNotSpam(post) {
    const stats = SpamFader.getPosterStats(post);
    stats.markNotSpam();

    stats.posts.forEach(function(p) {
      $(p).css('opacity', 1);
      $(p).off('mouseenter mouseleave');
      $(p).find(SpamFader.SPAM_BADGES_SELECTOR).remove();
      $(p).find(`.${SpamFader.NOT_SPAM_BUTTON_CLASS}`).remove();
    });

    SpamFader.addToNotSpamList(stats);
  }

  /**
   * Save not spam in localstorage
   * @param {PosterStats} posterStats
   */
  static addToNotSpamList(posterStats) {
    const threadId = EightKun.getThreadId();
    const notSpamList = SpamFader.getNotSpamList();
    if (!(threadId in notSpamList)) {
      notSpamList[threadId] = [];
    }
    if (!SpamFader.isMarkedAsNotSpam(posterStats)) {
      notSpamList[threadId].push(posterStats.posterId);
      localStorage.setItem(SpamFader.NOT_SPAM_SETTING,
          JSON.stringify(notSpamList));
    }
  }

  /**
   * Has this poster been marked as not spam?
   * @param {PosterStats} posterStats
   * @return {boolean} true if not spam
   */
  static isMarkedAsNotSpam(posterStats) {
    const threadId = EightKun.getThreadId();
    const notSpamList = SpamFader.getNotSpamList();
    return threadId in notSpamList &&
        notSpamList[threadId].includes(posterStats.posterId);
  }

  /**
   * Get not spam list from localStorage
   * @return {Array} map of thread to not spam poster ids
   */
  static getNotSpamList() {
    return JSON.parse(
        localStorage.getItem(SpamFader.NOT_SPAM_SETTING) || '{}',
    );
  }
}
SpamFader.posterStats = new Map();
SpamFader.FADE = 'fade';
SpamFader.HIDE = 'hide';
SpamFader.SPAM_BADGES_CLASS = 'bakertools-spam-badges';
SpamFader.SPAM_BADGES_SELECTOR = `.${SpamFader.SPAM_BADGES_CLASS}`;
SpamFader.MIN_OPACITY = .2;
SpamFader.ANIMATION_DURATION = 200; // milliseconds
SpamFader.SPAM_ACTION_SETTING = 'bakertools-spamfader-action';
SpamFader.HIDE_SPAM_BADGES_SETTING = 'bakertools-spamfader-hide-badges';
SpamFader.DISABLE_SPAM_FADER_SETTING = 'bakertools-spamfader-disable';
SpamFader.NOT_SPAM_SETTING = 'bakertools-spamfader-notspam';
SpamFader.NOT_SPAM_BUTTON_CLASS = 'bakertools-spamfader-notspam';
SpamFader.NOT_SPAM_BUTTON_SELECTOR = `.${SpamFader.NOT_SPAM_BUTTON_CLASS}`;

/**
 * Holds spam stats
 */
class PosterStats {
  /**
   * Construct poststats for post
   * @param {number} posterId id of poster
   */
  constructor(posterId) {
    this.posts = [];
    this.posterId = posterId;
    this.markNotSpam();
  }

  /**
   * Reset spam indicators
   */
  markNotSpam() {
    this._spamCertainty = 0;
    this._fadeProgress = 0;
    this.floodCount = 0;
    this.breadShitCount = 0;
    this.isBreadShitter = false;
  }

  /**
   * Add post to poster's list of post
   * @param {Element} post div.post
   */
  addPost(post) {
    if (!this.posts.includes(post)) {
      this.posts.push(post);
    }
  }

  /**
   * Set spam certainty property
   * @param {number} certainty
   */
  set spamCertainty(certainty) {
    if (certainty > this._spamCertainty) {
      this._spamCertainty = certainty;
    }
  }

  /**
   * Get spam spamCertainty
   * @return {number} 1 represents 100% certainty.
   */
  get spamCertainty() {
    return this._spamCertainty;
  }

  /**
   * Set fade progress property
   * @param {number} progress
   */
  set fadeProgress(progress) {
    if (progress > this._fadeProgress) {
      this._fadeProgress = progress;
    }
  }

  /**
   * Get spam fade progress
   * @return {number} 1 represents 100% progress.
   */
  get fadeProgress() {
    return this._fadeProgress;
  }

  /**
   * Number of posts by id
   * @return {number}
   */
  get postCount() {
    return this.posts.length;
  }

  /**
   * Is this post spam?
   * @return {boolean} true if spam
   */
  get isSpam() {
    return this._spamCertainty >= 1;
  }
}

/**
 * Base class for spamDetectionStrategies
 */
class SpamDetectionStrategy {
  /**
   * Determine if the provided post is spam
   * @param {Element} post div.post
   * @return {boolean} true if is spam
   */
  isSpam(post) {
    return false;
  }
}

/**
 * Marks namefags as spam
 */
class NameFagStrategy extends SpamDetectionStrategy {
  /**
   * Construct NameFagStrategy
   */
  constructor() {
    super();
    this.nameRegex = /^Anonymous( \(You\))?$/;
    this.badge = 'tag';
    this.badgeTitle = 'Namefag';
  }

  /**
   * Returns true if a namefag, sets spamCertainty to 100% for post
   * to begin fading
   * @param {Element} post div.post
   * @return {boolean} true if is namefag spam
   */
  isSpam(post) {
    const isNameFag = !window.bakerTools.qPostHighlighter.isQ(post) &&
    (
      !this.nameRegex.test(EightKun.getPostName(post)) ||
      EightKun.getPostTrip(post) != ''
    );

    if (isNameFag) {
      const stats = SpamFader.getPosterStats(post);
      stats.spamCertainty = 1;
      stats.fadeProgress = .2;
      stats.isNameFag = true;
      SpamFader.addSpamBadge(stats, this.badge, this.badgeTitle);
    }
    return isNameFag;
  }
}

/**
 * Marks floodfags with high post count as spam
 */
class HighPostCountFagStrategy extends SpamDetectionStrategy {
  /**
   * Construct HighPostCountFagStrategy
   */
  constructor() {
    super();
    this.postCountSpamThreshold = 15;
    this.postCountHideThreshold = 25;
    this.badge = 'bullhorn';
    this.badgeTitle = 'High Post Count Fag';
  }

  /**
   * Returns true if the poster has posted more than the threshold
   * @param {Element} post div.post
   * @return {boolean} true if spam
   */
  isSpam(post) {
    if (EightKun.isPostFromOp(post)) {
      return;
    }

    const posterStats = SpamFader.getPosterStats(post);

    const highCountSpamCertainty =
      Math.min(1, posterStats.postCount / this.postCountSpamThreshold);

    posterStats.spamCertainty = highCountSpamCertainty;

    if (highCountSpamCertainty === 1) {
      posterStats.isHighPostCountFag = true;
      SpamFader.addSpamBadge(posterStats, this.badge, this.badgeTitle);
    }

    // We already hit spam threshold
    // Either we have hit threshold count or some other strategy says its spam
    if (posterStats.isSpam) {
      // Number of posts needed past threshold to hide
      const hideCount =
        this.postCountHideThreshold - this.postCountSpamThreshold;

      const progressIncrement = 1/hideCount;

      posterStats.fadeProgress += progressIncrement;
    }
    return posterStats.isSpam;
  }
}

/**
 * Marks floodfags with quick succession posts as spam
 */
class FloodFagStrategy extends SpamDetectionStrategy {
  /**
   * Construct flood fag strategy
   */
  constructor() {
    super();
    this.postIntervalConsideredFlooding = 60; // seconds
    this.floodCountSpamThreshold = 5;
    this.floodCountHideThreshold = 10;
    this.badge = 'tint';
    this.badgeTitle = 'Floodfag';
  }

  /**
   * Returns true if a spam
   * @param {Element} post div.post
   * @return {boolean} true if is spam
   */
  isSpam(post) {
    const posterStats = SpamFader.getPosterStats(post);
    if (EightKun.isPostFromOp(post) || !this.isPostFlooded(posterStats)) {
      return;
    }
    posterStats.floodCount++;

    const floodSpamCertainty =
      Math.min(1, posterStats.floodCount / this.floodCountSpamThreshold);

    posterStats.spamCertainty = floodSpamCertainty;

    if (floodSpamCertainty === 1) {
      posterStats.isFloodFag = true;
      SpamFader.addSpamBadge(posterStats, this.badge, this.badgeTitle);
    }

    // We already hit spam threshold
    // Either we have hit threshold count or some other strategy says its spam
    if (posterStats.isSpam) {
      // Number of posts needed past threshold to hide
      const hideCount =
        this.floodCountHideThreshold - this.floodCountSpamThreshold;

      const progressIncrement = 1/hideCount;

      posterStats.fadeProgress += progressIncrement;
    }
    return posterStats.isSpam;
  }

  /**
   * Is this a flooded post?
   * @param {PosterStats} posterStats
   * @return {boolean} true if flooded
   */
  isPostFlooded(posterStats) {
    if (posterStats.posts.length <= 1) {
      return false;
    }
    const currentPost = posterStats.posts.slice(-1)[0];
    const previousPost = posterStats.posts.slice(-2)[0];
    const previousPostTime = EightKun.getPostTime(previousPost);
    const currentPostTime = EightKun.getPostTime(currentPost);
    return (currentPostTime - previousPostTime) <=
      this.postIntervalConsideredFlooding;
  }
}

/**
 * Marks breadshitters as spam
 */
class BreadShitterFagStrategy extends SpamDetectionStrategy {
  // TODO: dont check for bread shitting on non research thread?
  /**
   * Construct flood fag strategy
   */
  constructor() {
    super();
    // Let's go easy, maybe its a newfag?
    this.breadShittingIncrement = .1;
    this.badge = 'clock-o';
    this.badgeTitle = 'Bread shitter';
  }

  /**
   * Returns true if a spam
   * @param {Element} post div.post
   * @return {boolean} true if is spam
   */
  isSpam(post) {
    const posterStats = SpamFader.getPosterStats(post);
    if (EightKun.isPostFromOp(post) || !this.isBreadShitter(post)) {
      return;
    }
    posterStats.breadShitCount++;

    posterStats.isBreadShitter = true;
    SpamFader.addSpamBadge(posterStats, this.badge, this.badgeTitle);
    posterStats.spamCertainty = 1;
    posterStats.fadeProgress += this.breadShittingIncrement;

    return posterStats.isSpam;
  }

  /**
   * Is this a bread shitting post?
   * @param {Element} post div.post
   * @return {boolean} true if bread shitter
   */
  isBreadShitter(post) {
    const dough = ResearchBread.getDoughPost();
    const doughTime = EightKun.getPostTime(dough);
    const postTime = EightKun.getPostTime(post);

    return postTime <= doughTime;
  }
}

/* exported StatsOverlay */
/* global $, EightKun, QPostHighlighter, NotablePost, debounce */
/**
* Overlays bread stats (and some other controls) in the bottom right of the
* screen.
*/
class StatsOverlay {
  /**
   * Construct statsoverlay, html element, setup listeners
   */
  constructor() {
    this.id = 'bakertools-stats-overlay';
    this.maxPosts = 750;
    this.postCountId = 'bakertools-stats-post-count';
    this.userCountId = 'bakertools-stats-uid-count';
    this.qCountId = 'bakertools-stats-q-count';
    this.notableCountId = 'bakertools-stats-notable-count';

    this._createStyles();
    this._createElement();
    this._updateStats();
    $(document).on(EightKun.NEW_POST_EVENT, function(e, post) {
      this._updateStats();
    }.bind(this));
  }

  /**
   * Create styles for stats overlay
   */
  _createStyles() {
    const sheet = window.document.styleSheets[0];
    sheet.insertRule(`#${this.id} {
      padding: 5px;
      position: fixed;
      z-index: 100;
      float: right;
      right:28.25px;
      bottom: 28.25px;
    }`, sheet.cssRules.length);
  }

  /**
   * Create actual html element for style overlay
   */
  _createElement() {
    this.element = document.createElement('div');
    this.element.id = this.id;

    this.$goToLast = $(`
    <a href="javascript:void(0)" alt="last" title="Go to last reading location">
    <i class="fa fa-step-backward"></i>
    </a>`);


    this.saveLastReadingLocation = debounce(this.saveLastReadingLocation, 450);
    this.currentReadingLocation = $(window).scrollTop();
    $(window).scroll(function() {
      this.saveLastReadingLocation();
    }.bind(this));

    this.$goToLast.click(function() {
      $(window).scrollTop(this.lastReadingLocation);
    }.bind(this));

    $(this.element).append( `
    Posts: <span id="${this.postCountId}" ></span>
    UIDS: <span id="${this.userCountId}"></span>
    `);

    $(this.element).append(this.$goToLast);

    $(this.element).append(`
    <a href="#bottom" alt="to-bottom" title="Go to bottom">
    <i class="fa fa-angle-double-down"></i>
    </a>
    <a href="#top" alt="to-top" title="Go to top">
    <i class="fa fa-angle-double-up"></i>
    </a>

    <br/>

    Q's: <span id="${this.qCountId}" ></span>
    Notables: <span id="${this.notableCountId}"></span>
    `);
    document.body.appendChild(this.element);
    this._setPostCount($('div.post.reply').length);
  }

  /**
   * Save the last spot before scrolling or navigation
   */
  saveLastReadingLocation() {
    const scrollDistance = Math.abs(
        this.currentReadingLocation - $(window).scrollTop());
    const scrolledMoreThanThirdScreenHeight =
        scrollDistance > (window.innerHeight / 3);

    if (!scrolledMoreThanThirdScreenHeight) {
      return;
    }
    this.lastReadingLocation = this.currentReadingLocation;
    this.currentReadingLocation = $(window).scrollTop();
  }

  /**
   * Update the stats fields
   */
  _updateStats() {
    const postCount = $('#thread_stats_posts').text();

    if (postCount) {
      this._setPostCount(postCount);
    }
    // TODO: uids dont load at first load.
    $('#'+this.userCountId).text($('#thread_stats_uids').text() || '0');
    $('#'+this.qCountId).text(QPostHighlighter.qPosts.length);
    $('#'+this.notableCountId).text(NotablePost.getNotables().length);
  }

  /**
   * Set post count in overlay
   * @param {number} count
   */
  _setPostCount(count) {
    const progress = count/this.maxPosts;
    let postColor = 'green';
    if (progress >= .87) { // ~ 650 posts (100 posts left)
      postColor = 'red';
    } else if (progress >= .5) {
      postColor = 'goldenrod';
    }
    $('#'+this.postCountId).text(count).css({'color': postColor});
  }
} // End StatsOverlay class

/* global $, NavigationControl, EightKun, ResearchBread,
 ColorPicker, POST_BACKGROUND_CHANGE_EVENT */
/**
* Highlight posts that (you)
* Adds (You) navigation links to baker window
*/
class YouHighlighter {
  /**
   * Construct YN object
   */
  constructor() {
    this.styleId = 'bakertools-you-styles';
    this.yous = [];
    this.ownPosts = [];

    this.showYouNavigationInBoardListId =
        'bakertools-show-you-nav-in-boardlist';

    this.showOwnNavigationInBoardListId =
        'bakertools-show-own-nav-in-boardlist';

    this._createStyles();
    this._setupBakerWindowControls();
    this._readSettings();

    this._initOwnAndYouPosts();
    this._setupListeners();
  }

  /**
   * Create styles
   */
  _createStyles() {
    $('head').append(`
    <style id='${this.styleId}'>
    ${EightKun.POST_SELECTOR}.${YouHighlighter.YOU_CLASS} {
      background: ${this.youColor};
    }

    ${EightKun.POST_SELECTOR}.${YouHighlighter.OWN_CLASS} {
      background: ${this.ownPostColor};
    }
    </style>
    `);
  }

  /**
   * Read settings from localStorage
   */
  _readSettings() {
    this.showYouNavigationInBoardList(JSON.parse(
        localStorage.getItem(
            YouHighlighter.SHOW_YOU_NAV_IN_BOARDLIST_SETTING),
    ));

    this.showOwnNavigationInBoardList(JSON.parse(
        localStorage.getItem(
            YouHighlighter.SHOW_OWN_NAV_IN_BOARDLIST_SETTING),
    ));
  }

  /**
   * Add (you) navigation to bakerwindow
   */
  _setupBakerWindowControls() {
    const youColorPicker = new ColorPicker(
        '(You) Post Color',
        'Set background color of posts replying to (you)',
        YouHighlighter.YOU_COLOR_SETTING,
        YouHighlighter.DEFAULT_YOU_COLOR,
        (color) => this.youColor = color,
    );

    const ownPostColorPicker = new ColorPicker(
        'Own Post Color',
        'Set background color your own posts',
        YouHighlighter.OWN_COLOR_SETTING,
        YouHighlighter.DEFAULT_OWN_COLOR,
        (color) => this.ownPostColor = color,
    );

    window.bakerTools.mainWindow.addColorOption(youColorPicker.element);
    window.bakerTools.mainWindow.addColorOption(ownPostColorPicker.element);


    const youLabel = `(You)'s`;
    this.youNavigation = new NavigationControl(youLabel,
        this.getYous.bind(this), YouHighlighter.NEW_YOU_POST_EVENT);

    this.youBoardListNav = new NavigationControl(youLabel,
        this.getYous.bind(this), YouHighlighter.NEW_YOU_POST_EVENT);

    $('.boardlist:first').append(this.youBoardListNav.element);
    $(this.youBoardListNav.element).hide();

    window.bakerTools.mainWindow.addOption(`
    <label for="${this.showYouNavigationInBoardListId}"
      title="Show navigation controls in board list bar" >
      Show (You) Nav in Board List:
    </label>
    <input type="checkbox" id="${this.showYouNavigationInBoardListId}"
      title="Show navigation controls in board list bar" /><br />
    `);

    const ownLabel = `Own Posts`;
    this.ownNavigation = new NavigationControl(ownLabel,
        this.getOwnPosts.bind(this), YouHighlighter.NEW_OWN_POST_EVENT);

    this.ownBoardListNav = new NavigationControl(ownLabel,
        this.getOwnPosts.bind(this), YouHighlighter.NEW_OWN_POST_EVENT);

    $('.boardlist:first').append(this.ownBoardListNav.element);
    $(this.ownBoardListNav.element).hide();

    window.bakerTools.mainWindow.addOption(`
    <label for="${this.showOwnNavigationInBoardListId}"
      title="Show navigation controls in board list bar" >
      Show Own Post Nav in Board List:
    </label>
    <input type="checkbox" id="${this.showOwnNavigationInBoardListId}"
      title="Show navigation controls in board list bar" /><br />
    `);

    window.bakerTools.mainWindow.addNavigation(this.youNavigation.element);
    window.bakerTools.mainWindow.addNavigation(this.ownNavigation.element);
  }

  /**
   * Set the background color of posts replying to (you)
   * @param {string} color A valid css color value.
   *        E.G. ('#ff00ee', 'rgba()' or 'blue')
   */
  set youColor(color) {
    this._youColor = color;
    document.getElementById(this.styleId)
        .sheet.cssRules[0].style.background = color;
    $(document).trigger(POST_BACKGROUND_CHANGE_EVENT, color);
  }

  /**
   * Get background color for posts replying to (you)
   */
  get youColor() {
    return this._youColor;
  }

  /**
   * Set the background color of your own posts
   * @param {string} color A valid css color value.
   *        E.G. ('#ff00ee', 'rgba()' or 'blue')
   */
  set ownPostColor(color) {
    this._ownPostColor = color;
    document.getElementById(this.styleId)
        .sheet.cssRules[1].style.background = color;
    $(document).trigger(POST_BACKGROUND_CHANGE_EVENT, color);
  }

  /**
   * Get background color for your own posts
   */
  get ownPostColor() {
    return this._ownPostColor;
  }

  /**
   * Setup listeners for baker window controls
   */
  _setupListeners() {
    $('#'+this.showOwnNavigationInBoardListId).change(function(e) {
      this.showOwnNavigationInBoardList(e.target.checked);
    }.bind(this));

    $('#'+this.showYouNavigationInBoardListId).change(function(e) {
      this.showYouNavigationInBoardList(e.target.checked);
    }.bind(this));

    $(document).on(EightKun.NEW_POST_EVENT, function(e, post) {
      if (this.isAYou(post)) {
        this._addYouPost(post);
      }
      if (this.isOwnPost(post)) {
        this._addOwnPost(post);
      }
    }.bind(this));
  }

  /**
   * Show/hide you nav in boardlist
   *
   * @param {boolean} showYouNavInBoardList
   */
  showYouNavigationInBoardList(showYouNavInBoardList) {
    $('#'+this.showYouNavigationInBoardListId).prop('checked',
        showYouNavInBoardList);

    localStorage.setItem(YouHighlighter.SHOW_YOU_NAV_IN_BOARDLIST_SETTING,
        showYouNavInBoardList);

    if (showYouNavInBoardList) {
      $(this.youBoardListNav.element).show();
    } else {
      $(this.youBoardListNav.element).hide();
    }
  }

  /**
   * Show/hide own nav in boardlist
   *
   * @param {boolean} showOwnNavInBoardList
   */
  showOwnNavigationInBoardList(showOwnNavInBoardList) {
    $('#'+this.showOwnNavigationInBoardListId).prop('checked',
        showOwnNavInBoardList);

    localStorage.setItem(YouHighlighter.SHOW_OWN_NAV_IN_BOARDLIST_SETTING,
        showOwnNavInBoardList);

    if (showOwnNavInBoardList) {
      $(this.ownBoardListNav.element).show();
    } else {
      $(this.ownBoardListNav.element).hide();
    }
  }

  /**
   * Get (You)'s
   * @return {Array} of div.post
   */
  getYous() {
    return this.yous;
  }

  /**
   * Is the post replying to you
   * @param {Element} post div.post
   * @return {boolean} True if post is replying to you
   */
  isAYou(post) {
    return post.querySelector('.body')
        .innerHTML
        .indexOf('<small>(You)</small>') != -1;
  }

  /**
   * Is this your own post
   * @param {Element} post div.post
   * @return {boolean} True if post is you
   */
  isOwnPost(post) {
    return $(post).hasClass('you');
  }

  /**
   * Add you post and trigger event
   * @param {Element} post
   */
  _addYouPost(post) {
    this.yous.push(post);
    $(post).addClass(YouHighlighter.YOU_CLASS);
    $(document).trigger(YouHighlighter.NEW_YOU_POST_EVENT, post);
  }

  /**
   * Add own post and trigger event
   * @param {Element} post
   */
  _addOwnPost(post) {
    this.ownPosts.push(post);
    $(post).addClass(YouHighlighter.OWN_CLASS);
    $(document).trigger(YouHighlighter.NEW_OWN_POST_EVENT, post);
  }

  /**
   * Get own and you posts that are present at page load
   */
  _initOwnAndYouPosts() {
    const ownPosts = JSON.parse(localStorage.own_posts || '{}');
    const board = ResearchBread.BOARD_NAME;

    $('div.post').each(function(i, post) {
      const postId = $(post).attr('id').split('_')[1];
      if (ownPosts[board] &&
          ownPosts[board].indexOf(postId) !== -1) {
        this._addOwnPost(post);
      }

      EightKun.getReplyLinksFromPost(post).each(function(i, link) {
        const youPostId = EightKun.getPostNumberFromReplyLink(link);

        if (ownPosts[board] && ownPosts[board].indexOf(youPostId) !== -1) {
          this._addYouPost(post);
        }
      }.bind(this));
    }.bind(this));

    window.bakerTools.scrollBar.addPosts(this.ownPosts);
    window.bakerTools.scrollBar.addPosts(this.yous);
  }

  /**
   * Get own posts
   * @return {Array} of div.post
   */
  getOwnPosts() {
    return this.ownPosts;
  }
}
YouHighlighter.SHOW_YOU_NAV_IN_BOARDLIST_SETTING =
    'bakertools-show-you-nav-in-boardlist';
YouHighlighter.SHOW_OWN_NAV_IN_BOARDLIST_SETTING =
    'bakertools-show-own-nav-in-boardlist';
YouHighlighter.NEW_YOU_POST_EVENT =
    'bakertools-new-you-post-event';
YouHighlighter.NEW_OWN_POST_EVENT =
    'bakertools-new-own-post-event';
YouHighlighter.YOU_CLASS = 'bakertools-you-post';
YouHighlighter.OWN_CLASS = 'bakertools-own-post';
YouHighlighter.OWN_COLOR_SETTING =
    'bakertools-own-post-color';
YouHighlighter.YOU_COLOR_SETTING =
    'bakertools-you-post-color';
YouHighlighter.DEFAULT_OWN_COLOR = '#F8D2D2';
YouHighlighter.DEFAULT_YOU_COLOR = '#E1B3DA';


/* global ActivePage, $, QPostHighlighter, YouHighlighter, StatsOverlay,
 NotableHighlighter, BakerWindow, BlurImages, PreviousBreadHighlighter,
 NominatePostButtons, BreadList, ScrollbarNavigation, NotablePost,
 ImageBlacklist, PostRateChart, SpamFader */
/**
* MAIN
*/
if (ActivePage.isThread()) { // Only setup the tools if we are on a thread
  $(document).ready(function() {
    console.info('Thanks for using bakertools! For God and Country! WWG1WGA');
    window.bakerTools = {};
    window.bakerTools.mainWindow = new BakerWindow();
    window.bakerTools.scrollBar = new ScrollbarNavigation([
      NotablePost.NEW_NOTABLE_POST_EVENT,
      YouHighlighter.NEW_OWN_POST_EVENT,
      YouHighlighter.NEW_YOU_POST_EVENT,
      QPostHighlighter.NEW_Q_POST_EVENT,
    ]);
    new BlurImages();
    window.bakerTools.PreviousBreadHighlighter =
      new PreviousBreadHighlighter();
    window.bakerTools.notableHighlighter = new NotableHighlighter();
    window.bakerTools.qPostHighlighter = new QPostHighlighter();
    window.bakerTools.youHighlighter = new YouHighlighter();
    window.bakerTools.statsOverlay = new StatsOverlay();
    new NominatePostButtons();
    new BreadList();
    new ImageBlacklist();
    new PostRateChart();
    new SpamFader([new NameFagStrategy(), new HighPostCountFagStrategy(),
      new FloodFagStrategy(), new BreadShitterFagStrategy()]);
  });
}
}(window.jQuery));