class HashItem {
    public key: number;
    public value: string;
    public next: HashItem;

    constructor(key: number, value: string) {
        this.key = key;
        this.value = value;
    }
}

class HashMap {
    private capacity: number;
    private bucketArray: Array<HashItem>;
    private keysCount: number = 0;

    public constructor(capacity: number) {
        this.capacity = capacity;
        this.bucketArray = [];
    }
    private hash_function(key:number) {
        return key % this.capacity;
    }
    get size():number {
        return this.keysCount;
    }
    setItem(key:number, value:string) {
        const hash_index = this.hash_function(key);
        let node = this.getItem(key, hash_index);
        if (node) {
            node.value = value;
            return;
        }

        this.keysCount += 1;
        node = this.bucketArray[hash_index] || null;
        const newNode = new HashItem(key, value);
        newNode.next = node;
        this.bucketArray[hash_index] = newNode;
        
        this.checkLoadFactor();
    }
    getItem(key:number, hash_index: number = null) {
        if (!hash_index) {
            hash_index = this.hash_function(key);
        }
        let node = this.bucketArray[hash_index] || null;

        while (node) {
            // chained node is item - key found - replace next with current node
            if (node.key === key) {
                return node;
            }
            node = node.next;
        }

        // chained node is null - key not found
        return null;
    }
    deleteItem(key:number) {
        const hash_index = this.hash_function(key);
        let node = this.bucketArray[hash_index] || null;
        let prev: HashItem = null;

        while (node) {
            if (node.key === key) {
                break;
            }
            // chained node is item - key found - replace next with current node
            prev = node;
            node = node.next || null;
        }

        if (node === null) {
            return null;
        }

        this.keysCount -= 1;

        // chained node is item - key found, no next item - replace current with null
        if (prev) {
            prev.next = node.next;
        } else {
            this.bucketArray[hash_index] = node.next;
        }

        return node;
    }
    checkLoadFactor() {
        // If load factor goes beyond threshold, then 
        // double hash table size 
        if ((1.0*this.keysCount)/this.capacity >= 0.65) { 
            const bucketArrayTemp: Array<HashItem> = this.bucketArray; 
            this.bucketArray = []; 
            this.capacity = 2 * this.capacity; 
            this.keysCount = 0; 
  
            bucketArrayTemp.forEach( head => {
                while (head != null) { 
                    this.setItem(head.key, head.value); 
                    head = head.next; 
                }
            });
        } 
    }
}

mocha.setup('bdd');


var assert = chai.assert;

describe('Hash Map',()=>{
  
  it("should set 5 items",()=>{
    
     const hasht = new HashMap(10);
       
     hasht.setItem(3,"pop")
     hasht.setItem(4,"king")
     hasht.setItem(9,"april")
     hasht.setItem(50,"gowtham")
     hasht.setItem(100,"olo")
   
     assert.equal(5,hasht.size)
     
  })
  
  it("should add and get the new data ",()=>{
    
     const hasht = new HashMap(10);
       
     hasht.setItem(3,"pop")
     hasht.setItem(4,"king")
     hasht.setItem(9,"april")
     hasht.setItem(50,"gowtham")
     hasht.setItem(100,"olo")
   
     assert.equal("gowtham",hasht.getItem(50).value)
     assert.equal("pop",hasht.getItem(3).value)
     assert.equal("king",hasht.getItem(4).value)
     assert.equal("olo",hasht.getItem(100).value)
     assert.equal("april",hasht.getItem(9).value)
     
  })
  
  it("should delete first item from chain and manage to fetch all other items",()=>{
    
     const hasht = new HashMap(10);
       
     hasht.setItem(3,"pop")
     hasht.setItem(4,"king")
     hasht.setItem(9,"april")
     hasht.setItem(50,"gowtham")
     hasht.setItem(100,"olo")
     hasht.deleteItem(100,"olo")
   
     assert.equal("gowtham",hasht.getItem(50).value)
     assert.equal("pop",hasht.getItem(3).value)
     assert.equal("king",hasht.getItem(4).value)
     assert.equal("april",hasht.getItem(9).value)
     assert.equal(null,hasht.getItem(100))

     assert.equal(4,hasht.size)

  })
})



mocha.run()