/**
    * Logback: the reliable, generic, fast and flexible logging framework.
    * Copyright (C) 1999-2011, QOS.ch. All rights reserved.
    *
    * This program and the accompanying materials are dual-licensed under
    * either the terms of the Eclipse Public License v1.0 as published by
    * the Eclipse Foundation
    *
    *   or (per the licensee's choosing)
   *
   * under the terms of the GNU Lesser General Public License version 2.1
   * as published by the Free Software Foundation.
   */
  package ch.qos.logback.core.spi;
  
  import ch.qos.logback.core.CoreConstants;
  import ch.qos.logback.core.helpers.CyclicBuffer;
  
  import java.util.HashMap;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  
  /**
   * @author Ceki Gücü
   */
  public class CyclicBufferTrackerImpl<E> implements CyclicBufferTracker<E> {
  
    int bufferSize = DEFAULT_BUFFER_SIZE;
    int maxNumBuffers = DEFAULT_NUMBER_OF_BUFFERS;
    int bufferCount = 0;
  
    // 5 minutes
    static final int DELAY_BETWEEN_CLEARING_STALE_BUFFERS = 300 * CoreConstants.MILLIS_IN_ONE_SECOND;
  
  
    boolean isStarted = false;
  
    private Map<String, Entry> map = new HashMap<String, Entry>();
  
    private Entry head; // least recently used entries are towards the head
    private Entry tail; // most recently used entries are towards the tail
    long lastCheck = 0;
  
  
    public CyclicBufferTrackerImpl() {
      head = new Entry(null, null, 0);
      tail = head;
    }
  
    public int getBufferSize() {
      return bufferSize;
    }
  
    public void setBufferSize(int bufferSize) {
      this.bufferSize = bufferSize;
    }
  
    public int getMaxNumberOfBuffers() {
      return maxNumBuffers;
    }
  
    public void setMaxNumberOfBuffers(int maxNumBuffers) {
      this.maxNumBuffers = maxNumBuffers;
    }
  
    public CyclicBuffer<E> getOrCreate(String key, long timestamp) {
      Entry existing = map.get(key);
      if (existing == null) {
        CyclicBuffer<E> cb = processNewEntry(key, timestamp);
        return cb;
      } else {
        existing.setTimestamp(timestamp);
        moveToTail(existing);
        return existing.value;
      }
    }
  
    public void removeBuffer(String key) {
      Entry existing = map.get(key);
      if (existing != null) {
        bufferCount--;
        map.remove(key);
        unlink(existing);
        CyclicBuffer<E> cb = existing.value;
        if(cb != null) {
          cb.clear();
        }
      }
    }
  
    private CyclicBuffer<E> processNewEntry(String key, long timestamp) {
      CyclicBuffer<E> cb = new CyclicBuffer<E>(bufferSize);
      Entry entry = new Entry(key, cb, timestamp);
      map.put(key, entry);
      bufferCount++;
      linkBeforeTail(entry);
      if (bufferCount >= maxNumBuffers) {
        removeHead();
     }
     return cb;
   }
 
   private void removeHead() {
     CyclicBuffer cb = head.value;
     if (cb != null) {
       cb.clear();
     }
     map.remove(head.key);
     bufferCount--;
     head = head.next;
     head.prev = null;
   }
 
   private void moveToTail(Entry e) {
     unlink(e);
     linkBeforeTail(e);
   }
 
   private void unlink(Entry e) {
     if (e.prev != null) {
       e.prev.next = e.next;
     }
     if (e.next != null) {
       e.next.prev = e.prev;
     }
     if (head == e) {
       head = e.next;
     }
   }
 
 
   public synchronized void clearStaleBuffers(long now) {
     if (lastCheck + DELAY_BETWEEN_CLEARING_STALE_BUFFERS > now) {
       return;
     }
     lastCheck = now;
 
     while (head.value != null && isEntryStale(head, now)) {
       removeHead();
     }
   }
 
   public int size() {
     return map.size();
   }
 
   final private boolean isEntryStale(Entry entry, long now) {
     return ((entry.timestamp + THRESHOLD) < now);
   }
 
   List<String> keyList() {
     List<String> result = new LinkedList<String>();
     Entry e = head;
     while (e != tail) {
       result.add(e.key);
       e = e.next;
     }
     return result;
   }
 
   private void linkBeforeTail(Entry e) {
     if (head == tail) {
       head = e;
     }
     Entry preTail = tail.prev;
     if (preTail != null) {
       preTail.next = e;
     }
     e.prev = preTail;
     e.next = tail;
     tail.prev = e;
   }
 
   // ================================================================
 
   private class Entry {
     Entry next;
     Entry prev;
 
     String key;
     CyclicBuffer<E> value;
     long timestamp;
 
     Entry(String k, CyclicBuffer<E> v, long timestamp) {
       this.key = k;
       this.value = v;
       this.timestamp = timestamp;
     }
 
     public void setTimestamp(long timestamp) {
       this.timestamp = timestamp;
     }
 
     @Override
     public int hashCode() {
       final int prime = 31;
       int result = 1;
       result = prime * result + ((key == null) ? 0 : key.hashCode());
       return result;
     }
 
     @Override
     public boolean equals(Object obj) {
       if (this == obj)
         return true;
       if (obj == null)
         return false;
       if (getClass() != obj.getClass())
         return false;
       final Entry other = (Entry) obj;
       if (key == null) {
         if (other.key != null)
           return false;
       } else if (!key.equals(other.key))
         return false;
       if (value == null) {
         if (other.value != null)
           return false;
       } else if (!value.equals(other.value))
         return false;
       return true;
     }
 
     @Override
     public String toString() {
       return "(" + key + ", " + value + ")";
     }
   }
 }