const conf = require('../../config.js').database

const redis = require('redis')

let redisClient = null // redis.createClient();

const async = require('async')
const sets = require('simplesets')

// If you want Memory Store instead...
// var MemoryStore = require('connect/middleware/session/memory');
// var session_store = new MemoryStore();

const REDIS_PREFIX = '#scrumblr#'

// For Redis Debugging

const db = function(callback) {
  if (conf.sock) {
    console.log(`Opening redis connection to socket ${conf.host}`)
    redisClient = redis.createClient(conf.host)
  } else {
    console.log(`Opening redis connection to ${conf.host}:${conf.port}`)
    redisClient = redis.createClient(conf.port, conf.host, {})
  }
  redisClient.on('connect', (err) => {
    callback()
  })

  redisClient.on('error', (err) => {
    console.log(`Redis error: ${err}`)
  })
}

db.prototype = {
  clearRoom(room, callback) {
    redisClient.del(`${REDIS_PREFIX}-room:/demo-cards`, (err, res) => {
      redisClient.del(`${REDIS_PREFIX}-room:/demo-columns`, (err, res) => {
        callback()
      })
    })
  },

  // theme commands
  setTheme(room, theme) {
    redisClient.set(`${REDIS_PREFIX}-room:${room}-theme`, theme)
  },

  getTheme(room, callback) {
    redisClient.get(`${REDIS_PREFIX}-room:${room}-theme`, (err, res) => {
      callback(res)
    })
  },

  // revision commands
  setRevisions(room, revisions) {
    if (Object.keys(revisions).length === 0) {
      redisClient.del(`${REDIS_PREFIX}-room:${room}-revisions`)
    } else {
      redisClient.set(`${REDIS_PREFIX}-room:${room}-revisions`, JSON.stringify(revisions))
    }
  },

  getRevisions(room, callback) {
    redisClient.get(`${REDIS_PREFIX}-room:${room}-revisions`, (err, res) => {
      callback(JSON.parse(res))
    })
  },

  // Column commands
  createColumn(room, name, callback) {
    redisClient.rpush(
      `${REDIS_PREFIX}-room:${room}-columns`,
      name,
      (err, res) => {
        if (typeof callback != 'undefined' && callback !== null) callback()
      }
    )
  },

  getAllColumns(room, callback) {
    redisClient.lrange(`${REDIS_PREFIX}-room:${room}-columns`, 0, -1, (err, res) => {
      callback(res)
    })
  },

  deleteColumn(room) {
    redisClient.rpop(`${REDIS_PREFIX}-room:${room}-columns`)
  },

  setColumns(room, columns) {
    // 1. first delete all columns
    redisClient.del(`${REDIS_PREFIX}-room:${room}-columns`, () => {
      // 2. now add columns for each thingy
      async.forEachSeries(
        columns,
        (item, callback) => {
          // console.log('rpush: ' + REDIS_PREFIX + '-room:' + room + '-columns' + ' -- ' + item);
          redisClient.rpush(
            `${REDIS_PREFIX}-room:${room}-columns`,
            item,
            (err, res) => {
              callback()
            }
          )
        },
        () => {
          // this happens when the series is complete
        }
      )
    })
  },

  // Card commands
  createCard(room, id, card) {
    const cardString = JSON.stringify(card)
    redisClient.hset(
      `${REDIS_PREFIX}-room:${room}-cards`,
      id,
      cardString
    )
  },

  getAllCards(room, callback) {
    redisClient.hgetall(`${REDIS_PREFIX}-room:${room}-cards`, (err, res) => {
      const cards = []

      for (const i in res) {
        cards.push(JSON.parse(res[i]))
      }
      // console.dir(cards);

      callback(cards)
    })
  },

  cardEdit(room, id, text) {
    redisClient.hget(`${REDIS_PREFIX}-room:${room}-cards`, id, (err, res) => {
      const card = JSON.parse(res)
      if (card !== null) {
        card.text = text
        redisClient.hset(`${REDIS_PREFIX}-room:${room}-cards`, id, JSON.stringify(card))
      }
    })
  },

  cardSetXY(room, id, x, y) {
    redisClient.hget(`${REDIS_PREFIX}-room:${room}-cards`, id, (err, res) => {
      const card = JSON.parse(res)
      if (card !== null) {
        card.x = x
        card.y = y
        redisClient.hset(`${REDIS_PREFIX}-room:${room}-cards`, id, JSON.stringify(card))
      }
    })
  },

  deleteCard(room, id) {
    redisClient.hdel(
      `${REDIS_PREFIX}-room:${room}-cards`,
      id
    )
  },

  addSticker(room, cardId, stickerId) {
    redisClient.hget(`${REDIS_PREFIX}-room:${room}-cards`, cardId, (err, res) => {
      const card = JSON.parse(res)
      if (card !== null) {
        if (stickerId === 'nosticker') {
          card.sticker = null

          redisClient.hset(`${REDIS_PREFIX}-room:${room}-cards`, cardId, JSON.stringify(card))
        } else {
          if (card.sticker !== null) { stickerSet = new sets.Set(card.sticker) } else { stickerSet = new sets.Set() }

          stickerSet.add(stickerId)

          card.sticker = stickerSet.array()

          redisClient.hset(`${REDIS_PREFIX}-room:${room}-cards`, cardId, JSON.stringify(card))
        }
      }
    })
  },

  setBoardSize(room, size) {
    redisClient.set(`${REDIS_PREFIX}-room:${room}-size`, JSON.stringify(size))
  },

  getBoardSize(room, callback) {
    redisClient.get(`${REDIS_PREFIX}-room:${room}-size`, (err, res) => {
      callback(JSON.parse(res))
    })
  }

}
exports.db = db