// Name : Wisly Er Jia Le
// ID: 230369412
// Date: 8 Jan 2024
// Brief Description : The purpose of this program is to examine and pinpoint rhymes in a given set of words. It uses a dynamic linked list and a static array, 
//                     two different types of data structures. The main goal is to see if a word rhymes by comparing its last two characters. 

// Static Array
target_Words = ['bend', 'lend', 'blend', 'tend', 'computer'];
rhymes_Word = ['fend'];

rhymes_WordLocation = rhymes_Word[0]; // rhymes_WordLocation contain the word fend

// Algorithm
// To compare the last 3 character
function Last_ThreeChar() 
{
    // To iterates through each element in the array "target_Words"
    for (let i = 0; i < target_Words.length; i++) 
    {

      current_TargetWords = target_Words[i]; // current_TargetWords contain the element in target_Words based on the loop
      
     
    // Check if last 3 characters in target_Words is equal rhymes_Word
    // Convert all characters to lowercase and compare last 3 character
      if ((current_TargetWords[current_TargetWords.length-3].toLowerCase() == rhymes_WordLocation[rhymes_WordLocation.length-3].toLowerCase()) &&
          (current_TargetWords[current_TargetWords.length-2].toLowerCase() == rhymes_WordLocation[rhymes_WordLocation.length-2].toLowerCase()) && 
          (current_TargetWords[current_TargetWords.length-1].toLowerCase() == rhymes_WordLocation[rhymes_WordLocation.length-1].toLowerCase())) 
            // Print "contains the same last 3 characters and rhymes" if last 3 characters match
            console.log(target_Words[i] + ' and ' + rhymes_WordLocation + " contains the same last 3 characters and rhymes")
      else
            // print "does not contains the same last 3 characters and does not rhymes" if last 3 characters does not match
            console.log(target_Words[i] + ' and ' + rhymes_WordLocation + " does not contains the same last 3 characters and does not rhymes") 
    }
    
    console.log('\n'); // To separate between Two different algorithms and data structure
}

// Linked list
// To allow interaction with the file such as reading or writing to file
const fs = require('fs');

class Node
{
    // constructor
    constructor(word)
    {
        this.word = word; // Data store
        this.next = null // Point to the next node
    }
}
// linkedlist class
class LinkedList
{
    constructor()
    {
        this.head = null; // head point to the first node
        this.size = 0; // The number of element in the list
    }
 
    // adds an element at the end
    // of list
    add(word) 
    {
        
        var node = new Node(word); // creates a new node
        
        var current; // to store current node
 
        // if list is Empty add the
        // element and make it head
        if (this.head == null)
            this.head = node;
        else 
        {
            current = this.head;
 
            // iterate to the end of the
            // list
            while (current.next)
            {
                current = current.next;
            }
 
            current.next = node; // add node at the end
        }
        
        this.size++; //  To keep track of the number of elements
    }
    
    // To compare the last 2 character
    checkWord(word1, word2)
    {
    const len1 = word1.length;
    const len2 = word2.length;
    
    // Convert all characters to lowercase and compare last 2 character
    return (
      word1[word1.length-2].toLowerCase() == word2[word2.length-2].toLowerCase() &&
      word1[word1.length-1].toLowerCase() == word2[word2.length-1].toLowerCase()
    );
  }

 // Check for rhyme between the elements
  checkWordInList()
  {
    
    let current = this.head; // Variable current point to head

    while (current && current.next)
    {
      // To check if current node and the next node are in the linked list
      // to check for consecutive pairs of words
      if (this.checkWord(current.word, current.next.word))
        {
          console.log(current.word + ' and '+  current.next.word + " rhyme! It contains the same last 2 characters");
        }
      else
        {
          console.log(current.word + ' and ' + current.next.word + " do not rhyme! It does not contains the same last 2 characters");
        }
      
      current = current.next;
      
    }
  }
}

// Call Last_ThreeChar
Last_ThreeChar();
 
 // Read words from input.txt
const textFile = fs.readFileSync('Input.txt', 'utf-8').split('\n');

// creating an object for the
// Linkedlist class
const linkedList = new LinkedList();
textFile.forEach(word => linkedList.add(word.trim()));

// Check for rhyme in the linked list
linkedList.checkWordInList();