import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;

public class SimpleWebCrawler {

    public static void main(String[] args) {
        String urlString = "https://www.kirkwood.edu";
        
//         String urlString = String.format("https://graphical.weather.gov/"
//                 + "xml/sample_products/browser_interface/ndfdXMLclient.php?"
//                 + "lat=41.911150&lon=-91.652149&product=time-series&"
//                 + "begin=%s&end=%s&maxt=maxt&mint=mint", LocalDateTime.now().with(LocalTime.MIN), LocalDateTime.now().with(LocalTime.MAX));
        try {
            // NOTE: Once a URL object is created, you cannot change it.
            URL url = new URL(urlString);
            BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream()));
            String line;
            int lineNumber = 1;
            while ((line = reader.readLine()) != null) {
                System.out.printf("%4d %s\n", lineNumber++, line);
            }
        } catch (MalformedURLException ex) {
            System.out.println("ERROR: MalformedURLException " + ex.getMessage());
        } catch (IOException ex) {
            System.out.println("ERROR: IOException " + ex.getMessage());
        }
    }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;

public class IntermediateWebCrawler {
    public static void main(String[] args) {
        String pageContent = getPageContent();
        List<Shoe> shoes = getShoes(pageContent);
        shoes.forEach(System.out::println);
    }

    public static List<Shoe> getShoes(String pageContent) {
        List<Shoe> shoes = new ArrayList<>();
        int indexStartH2 = pageContent.indexOf("<h2>");
        while(indexStartH2 >= 0) {
            Shoe shoe = new Shoe();
            // Get ranking
            int indexStartRanking = indexStartH2 + 4;
            int indexEndRanking = pageContent.indexOf(".", indexStartRanking);
            String ranking = pageContent.substring(indexStartRanking, indexEndRanking);
//            System.out.println(ranking);
            shoe.setRanking(Integer.parseInt(ranking));

            // Get shoe name
            int indexStartShoeName = indexEndRanking + 2;
            int indexEndShoeName = pageContent.indexOf("</h2>", indexStartShoeName);
            String shoeName = pageContent.substring(indexStartShoeName, indexEndShoeName);
//            System.out.println(shoeName);
            shoe.setShoeName(shoeName);

            // Get image
            int indexStartShoeImage = pageContent.indexOf("https", indexEndShoeName);
            int indexEndShoeImage = pageContent.indexOf(".jpg", indexStartShoeImage) + 4;
            String shoeImage = pageContent.substring(indexStartShoeImage, indexEndShoeImage);
//            System.out.println(shoeImage);
            shoe.setShoeImage(shoeImage);


            shoes.add(shoe);
            indexStartH2 = pageContent.indexOf("<h2>", indexStartH2 + 1);
        }
        return shoes;
    }

    public static String getPageContent() {
        String urlString = "https://www.espn.com/sportsnation/story/_/id/14734617/ranking-every-air-jordan-sneaker-1-xx9";
        //        String urlString = "https://www.espn.com/espn/feature/story/_/id/39771146/sneakerhead-guide-every-nba-wnba-signature-sneaker-history";
        String pageContent = "";
        try {
            // NOTE: Once a URL object is created, you cannot change it.
            URL url = new URL(urlString);
            BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream()));
            String line;
            while ((line = reader.readLine()) != null) {
                pageContent += line;
            }
        } catch (MalformedURLException ex) {
            System.out.println("ERROR: MalformedURLException " + ex.getMessage());
        } catch (IOException ex) {
            System.out.println("ERROR: IOException " + ex.getMessage());
        }
        return pageContent;
    }
}

class Shoe {
    private int ranking;
    private String shoeName;
    private String shoeImage;

    public Shoe() {
    }

    public int getRanking() {
        return ranking;
    }

    public void setRanking(int ranking) {
        this.ranking = ranking;
    }

    public String getShoeName() {
        return shoeName;
    }

    public void setShoeName(String shoeName) {
        this.shoeName = shoeName;
    }

    public String getShoeImage() {
        return shoeImage;
    }

    public void setShoeImage(String shoeImage) {
        this.shoeImage = shoeImage;
    }

    @Override
    public String toString() {
        return "ESPNShoe{" +
                "ranking=" + ranking +
                ", shoeName='" + shoeName + '\'' +
                ", shoeImage='" + shoeImage + '\'' +
                '}';
    }
}

public class Printer implements Runnable {
    @Override
    public void run() {
        System.out.println("Hello I'm a thread!");
    }
}

public class PrinterController {
    public static void main(String[] args) {
        Printer printer1 = new Printer();
        Thread thread = new Thread(printer1);
        thread.start();
    }
}

public class Printer extends Thread {

    @Override
    public void run() {
        System.out.println("Hello I'm a thread!");
    }
}

public class PrinterController {
    public static void main(String[] args) {
        Printer printer1 = new Printer();
        printer1.start();
    }
}

public class Printer extends Thread {

    public Printer(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println("Starting '" + this.getName() + "' thread.");
        System.out.println("Ending '" + this.getName() + "' thread.");
    }
}

public class PrinterController {
    public static void main(String[] args) {
        Printer printer1 = new Printer("Epson");
        printer1.start();
        
        Printer printer2 = new Printer("HP");
        printer2.start();
        
        Printer printer3 = new Printer("Brother");
        printer3.start();
        
        Printer printer4 = new Printer("Xerox");
        printer4.start();
    }
}

public class PrinterController {
    public static void main(String[] args) throws InterruptedException {
    	Printer printer1 = new Printer("Epson");
        printer1.start();
        printer1.join();
		// The second thread will start running only after the first thread is finished
        
        Printer printer2 = new Printer("HP");
        printer2.start();
        printer2.join();
		// The third thread will start running only after the second thread is finished
        
        Printer printer3 = new Printer("Brother");
        printer3.start();
        printer3.join();
		// The main thread will continue running only after the third thread is finished
        
        Printer printer4 = new Printer("Xerox");
        printer4.start();
        printer4.join();
		// The main thread will continue running only after the fourth thread is finishe
        
    }
}

public class ClockController {

    public static void main(String[] args) throws InterruptedException {
        Clock clock = new Clock(); // clock is a child thread of the main thread.
        clock.start(); // The main thread starts the child thread.
    }
}

public class Clock extends Thread {
    public void run() {
        while (true) {
        	System.out.println("Tick"); // writes the word Tick to the console once a second
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                
            }
        }
        System.out.println("BOOM!");
    }
}

public class Clock extends Thread {
    public void run() {
        while (true) {
        	System.out.println("Tick"); // writes the word Tick to the console once a second
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                break
            }
        }
        System.out.println("BOOM!");
    }
}

public class ClockManager {

    public static void main(String[] args) throws InterruptedException {
        Clock clock = new Clock(); // clock is a child thread of the main thread.
        clock.start(); // The main thread starts the child thread.
        Thread.sleep(5000); // Wait 5 seconds...
        clock.interrupt(); // ... then stop the task.
    }

}

public class Clock extends Thread {
    public void run() {
        // writes the word Tick to the console once a second 
        // as long the thread has not been interrupted.
        while (!isInterrupted()) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                break;
            }
            System.out.println("Tick");
        }
    }
}

import com.azure.communication.email.EmailClient;
import com.azure.communication.email.EmailClientBuilder;
import io.github.cdimascio.dotenv.Dotenv;

public class AzureEmail {
    public static EmailClient getEmailClient() {
        String connectionString = Dotenv.load().get("AZURE_EMAIL_CONNECTION");

        EmailClient emailClient = new EmailClientBuilder()
                .connectionString(connectionString)
                .buildClient();

        return emailClient;
    }
}

// code omitted
import com.azure.communication.email.models.EmailAddress;
import com.azure.communication.email.models.EmailMessage;
import com.azure.communication.email.models.EmailSendResult;
import com.azure.core.util.polling.PollResponse;
import com.azure.core.util.polling.SyncPoller;
import edu.kirkwood.ecommerce.thread.ContactUsEmail;

import org.jsoup.Jsoup;

public class AzureEmail {
    // code omitted

    public static String sendEmail(String toEmailAddress, String subject, String bodyHTML) {
        EmailClient emailClient = getEmailClient();
        EmailAddress toAddress = new EmailAddress(toEmailAddress);

        String body = Jsoup.parse("bodyHTML").text();

        EmailMessage emailMessage = new EmailMessage()
                .setSenderAddress(Dotenv.load().get("AZURE_EMAIL_FROM"))
                .setToRecipients(toAddress)
                .setSubject(subject)
                .setBodyPlainText(body)
                .setBodyHtml(bodyHTML);
        SyncPoller<EmailSendResult, EmailSendResult> poller = null;
        try {
            poller = emailClient.beginSend(emailMessage, null);
        } catch(RuntimeException e) {
            return e.getMessage();
        }
        PollResponse<EmailSendResult> result = poller.waitForCompletion();

        return "";
    }
}

public static void main(String[] args) {

    String toEmailAddress = "abc@example.com"; // Get emailAddress parameter
    boolean error =false;
    if(toEmailAddress == null || !Validators.isValidEmail(toEmailAddress)) {
        // set emailAddress-error attribute
        System.out.println("Invalid email address: " + toEmailAddress);
        error = true;
    }
    String subject = "Testing"; // Get subject parameter
    if(subject == null || subject.isEmpty()) {
        // set subject-error attribute
        System.out.println("Subject is required");
        error = true;
    }
    String bodyHTML = "<h2>This is a test email</h2><p>Testing, Testing, Testing</p>"; // Get messageBody parameter
    if(bodyHTML == null || bodyHTML.isEmpty()) {
        // set messageBody-error attribute
        System.out.println("Body is required");
        error = true;
    }
    if(!error) {
        String errorMessage = sendEmail(toEmailAddress, subject, bodyHTML);
        if (errorMessage.isEmpty()) {
        	// set send-success attribute
            System.out.println("Message sent to " + toEmailAddress);
        } else {
        	// Set send-error attribute
            System.out.println("Message not sent to " + toEmailAddress + " - " + errorMessage);
        }
    }
}

// Source: Google Gemini
public static boolean isValidEmail(String email) {
    String regex = "^[a-zA-Z0-9_!#$%&'*+/=?`{|}~^.-]+@[a-zA-Z0-9.-]+$";
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(email);
    return matcher.matches();
}

EmailThread emailThread1 = new EmailThread("marc.hauschildt@gmail.com", "Testing Thread", "<h2>Testing Thread</h2>");
emailThread1.start();
EmailThread emailThread2 = new  EmailThread("mlhauschildt@yahoo.com", "Testing Thread", "<h2>Testing Thread</h2>");
emailThread2.start();
if (emailThread1.getErrorMessage().isEmpty()) {
    System.out.println("Message sent to " + emailThread1.getToEmailAddress());
} else {
    System.out.println("Message not sent to " + emailThread1.getToEmailAddress() + " - " + emailThread1.getErrorMessage());
}
if (emailThread2.getErrorMessage().isEmpty()) {
    System.out.println("Message sent to " + emailThread2.getToEmailAddress());
} else {
    System.out.println("Message not sent to " + emailThread2.getToEmailAddress() + " - " + emailThread2.getErrorMessage());
}

public class EmailThread extends Thread {
    private String toEmailAddress;
    private String subject;
    private String bodyHTML;
    private String errorMessage;

    public EmailThread(String toEmailAddress, String subject, String bodyHTML) {
        this.toEmailAddress = toEmailAddress;
        this.subject = subject;
        this.bodyHTML = bodyHTML;
    }

    @Override
    public void run() {
        errorMessage = AzureEmail.sendEmail(toEmailAddress, subject, bodyHTML);
        // TODO: If an error occurs, try a backup email service.
    }

    public String getToEmailAddress() {
        return toEmailAddress;
    }

    public String getErrorMessage() {
        return errorMessage;
    }
}

public class MyThread implements Runnable {
    public Thread thread;
    
    public MyThread(String name) {
        thread = new Thread(this, name);
    }
    
    // a factory method that creates, starts, and returns a thread
    public static void createAndStart(String name) {
        MyThread mt = new MyThread(name);
        mt.thread.start();
    }
    
    @Override
    public void run() {
        System.out.println(thread.getName() + " thread starting.");
        try {
          for (int i = 0; i < 10; i++) {
              Thread.sleep(400);
              System.out.println("In " + thread.getName() + ", count is " + i);
          }  
        } catch(InterruptedException ex) {
            System.out.println(thread.getName() + " interrupted");
        }
        System.out.println(thread.getName() + " thread ending");
    }
}

public class UseThreads {
    public static void main(String[] args) {
        System.out.println("Main thread starting");
        MyThread.createAndStart("Child #1");
        for(int i = 0; i < 50; i++) {
            System.out.print(".");
            try {
                Thread.sleep(100);
            } catch (InterruptedException ex) {
                System.out.println("Main thread interrupted");
            }
        }
        System.out.println("Main thread ending");
    }
}

public class UseThreads {
    public static void main(String[] args) {
        System.out.println("Main thread starting");
        MyThread.createAndStart("Child #1");
        MyThread.createAndStart("Child #2");
        MyThread.createAndStart("Child #3");
        for(int i = 0; i < 50; i++) {
            System.out.print(".");
            try {
                Thread.sleep(100);
            } catch (InterruptedException ex) {
                System.out.println("Main thread interrupted");
            }
        }
        System.out.println("Main thread ending");
    }
}

public class MyThread extends Thread {

    public MyThread(String name) {
        super(name);
    }
    
    public static MyThread createAndStart(String name) {
        MyThread mt = new MyThread(name);
        mt.start();
        return mt;
    }
    
    @Override
    public void run() {
        System.out.println(getName() + " thread starting.");
        try {
          for (int i = 0; i < 10; i++) {
              Thread.sleep(400);
              System.out.println("In " + getName() + ", count is " + i);
          }  
        } catch(InterruptedException ex) {
            System.out.println(getName() + " interrupted");
        }
        System.out.println(getName() + " thread ending");
    }
}

public class UseThreads {
    public static void main(String[] args) {
        System.out.println("Main thread starting");
        MyThread mt = MyThread.createAndStart("Child #1");
        for(int i = 0; i < 50; i++) {
            System.out.print(".");
            try {
                Thread.sleep(100);
            } catch (InterruptedException ex) {
                System.out.println("Main thread interrupted");
            }
        }
        System.out.println("Main thread ending");
    }
}

public class UseThreads {
    public static void main(String[] args) {
        System.out.println("Main thread starting");
        MyThread mt1 = MyThread.createAndStart("Child #1");
        MyThread mt2 = MyThread.createAndStart("Child #2");
        MyThread mt3 = MyThread.createAndStart("Child #3");
        do {
            System.out.print(".");
            try {
                Thread.sleep(100);
            } catch (InterruptedException ex) {
                System.out.println("Main thread interrupted");
            }
        } while(mt1.thread.isAlive() || mt2.thread.isAlive() || mt3.thread.isAlive());
        System.out.println("Main thread ending");
    }
}

public class UseThreads {
    public static void main(String[] args) {
        System.out.println("Main thread starting");
        MyThread mt1 = MyThread.createAndStart("Child #1");
        MyThread mt2 = MyThread.createAndStart("Child #2");
        MyThread mt3 = MyThread.createAndStart("Child #3");
        try {
            mt1.thread.join();
            System.out.println("Child #1 joined");
            mt2.thread.join();
            System.out.println("Child #2 joined");
            mt3.thread.join();
            System.out.println("Child #3 joined");
        } catch (InterruptedException ex) {
            System.out.println("Main thread interrupted");
        }
        System.out.println("Main thread ending");
    }
}

public class UseThreads {
    public static void main(String[] args) {
        System.out.println("Main thread starting");
        MyThread mt1 = MyThread.createAndStart("Child #1");
        mt1.thread.setPriority(Thread.MIN_PRIORITY);
        MyThread mt2 = MyThread.createAndStart("Child #2");
        mt2.thread.setPriority(Thread.MAX_PRIORITY);
        MyThread mt3 = MyThread.createAndStart("Child #3");
        mt3.thread.setPriority(Thread.NORM_PRIORITY);
        try {
            mt1.thread.join();
            System.out.println("Child #1 joined");
            mt2.thread.join();
            System.out.println("Child #2 joined");
            mt3.thread.join();
            System.out.println("Child #3 joined");
        } catch (InterruptedException ex) {
            System.out.println("Main thread interrupted");
        }
        System.out.println("Main thread ending");
    }
}

public class MyThread implements Runnable {
    public Thread thread;
    
    public MyThread(String name) {
        thread = new Thread(this, name);
    }
    
    public static MyThread createAndStart(String name) {
        MyThread mt = new MyThread(name);
        mt.thread.start();
        return mt;
    }
    
    @Override
    public void run() {
        System.out.println(thread.getName() + " thread starting with priority: " + thread.getPriority() + ".");
        try {
          for (int i = 0; i < 10; i++) {
              Thread.sleep(400);
              System.out.println("In " + thread.getName() + ", count is " + i);
          }  
        } catch(InterruptedException ex) {
            System.out.println(thread.getName() + " interrupted");
        }
        System.out.println(thread.getName() + " thread ending");
    }
}

public class SumArray {
    private int sum;
    
    public synchronized int sumArray(int[] nums) {
        sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
            System.out.println("Running total for " + Thread.currentThread().getName() + " is " + sum);
            try {
                Thread.sleep(10);
            } catch (InterruptedException ex) {
                System.out.println("Thread interruped");
            }
        }
        return sum;
    }
}

public class MyThread implements Runnable {
    public Thread thread;
    public static SumArray sa = new SumArray();
    int[] a;
    int answer;
    
    public MyThread(String name, int[] nums) {
        thread = new Thread(this, name);
        a = nums;
    }
    
    public static MyThread createAndStart(String name, int[] nums) {
        MyThread mt = new MyThread(name, nums);
        mt.thread.start();
        return mt;
    }
    
    @Override
    public void run() {
        int sum;
        System.out.println(thread.getName() + " thread starting with priority: " + thread.getPriority() + ".");
        answer = sa.sumArray(a);
        System.out.println("Sum for " + thread.getName() + " is " + answer);
        System.out.println(thread.getName() + " thread ending");
    }
}

public class UseThreads {
    public static void main(String[] args) {
        int[] a = {1, 2, 3, 4, 5};
        System.out.println("Main thread starting");
        MyThread mt1 = MyThread.createAndStart("Child #1", a);
        mt1.thread.setPriority(Thread.MIN_PRIORITY);
        MyThread mt2 = MyThread.createAndStart("Child #2", a);
        mt2.thread.setPriority(Thread.MAX_PRIORITY);
        MyThread mt3 = MyThread.createAndStart("Child #3", a);
        mt3.thread.setPriority(Thread.NORM_PRIORITY);
        try {
            mt1.thread.join();
            System.out.println("Child #1 joined");
            mt2.thread.join();
            System.out.println("Child #2 joined");
            mt3.thread.join();
            System.out.println("Child #3 joined");
        } catch (InterruptedException ex) {
            System.out.println("Main thread interrupted");
        }
        System.out.println("Main thread ending");
    }
}

public class MyThread implements Runnable {
    public Thread thread;
    public static SumArray sa = new SumArray();
    int[] a;
    int answer;
    
    public MyThread(String name, int[] nums) {
        thread = new Thread(this, name);
        a = nums;
    }
    
    public static MyThread createAndStart(String name, int[] nums) {
        MyThread mt = new MyThread(name, nums);
        mt.thread.start();
        return mt;
    }
    
    @Override
    public void run() {
        int sum;
        System.out.println(thread.getName() + " thread starting with priority: " + thread.getPriority() + ".");
        synchronized(sa) {
            answer = sa.sumArray(a);
        }
        System.out.println("Sum for " + thread.getName() + " is " + answer);
        System.out.println(thread.getName() + " thread ending");
    }
}

import java.util.ArrayList;

public class Hopper<T> {

    private final ArrayList<T> items;

    public Hopper() {
        items = new ArrayList<>();
    }

    public synchronized ArrayList<T> getList(){
        return items;
    }

    public synchronized T getItem(){
        T item = null;
        if(!items.isEmpty()){
            item = items.get(0);
            items.remove(item);
        }
        return item;
    }

    public synchronized void addItem(T item){
        items.add(item);
    }

    public synchronized boolean isEmpty(){
        return items.isEmpty();
    }
}

import java.time.LocalDateTime;

public class Wheel {

    private String source;
    private LocalDateTime createDate;

    public Wheel(String source, LocalDateTime createDate) {
        this.source = source;
        this.createDate = createDate;
    }

    @Override
    public String toString() {
        return "Wheel[" + "source=" + source + ", created on: " + createDate + ']';
    }

    public String getSource() {
        return source;
    }

    public void setSource(String source) {
        this.source = source;
    }

    public LocalDateTime getCreateDate() {
        return createDate;
    }

    public void setCreateDate(LocalDateTime createDate) {
        this.createDate = createDate;
    }

}

import java.time.LocalDateTime;

public class Axle {
    private String source;
    private LocalDateTime createDate;

    public Axle(String source, LocalDateTime createDate) {
        this.source = source;
        this.createDate = createDate;
    }

    @Override
    public String toString() {
        return "Axle[" + "source=" + source + ", created on: " + createDate + ']';
    }

    public String getSource() {
        return source;
    }

    public void setSource(String source) {
        this.source = source;
    }

    public LocalDateTime getCreateDate() {
        return createDate;
    }

    public void setCreateDate(LocalDateTime createDate) {
        this.createDate = createDate;
    }

}

public class AssemblyLine {

    public static void main(String[] args) {
        Hopper<Wheel> wheels = new Hopper<>();
        Hopper<Axle> axles = new Hopper<>();
    }

}

import java.time.LocalDateTime;

public class WheelMaker implements Runnable {

    private final Hopper hopper;
    private int wheelCount;
    private final String lineName;
    
    public WheelMaker(Hopper hopper, int wheelCount, String lineName) {
        this.hopper = hopper;
        this.wheelCount = wheelCount;
        this.lineName = lineName;
    }
    
    @Override
    public void run() {
        Wheel wheel;
        while (wheelCount > 0) {
            wheelCount--;
            wheel = new Wheel(lineName, LocalDateTime.now());
            System.out.println("Adding wheel: " + wheel);
            hopper.addItem(wheel);
            try {
                Thread.sleep(2000);
            } catch (InterruptedException ie) {
                // ignore for the moment
            }
        }
    }

}

import java.time.LocalDateTime;

public class AxleMaker implements Runnable {

    private final Hopper hopper;
    private int axleCount;
    private final String lineName;
    
    public AxleMaker(Hopper hopper, int axleCount, String lineName) {
        this.hopper = hopper;
        this.axleCount = axleCount;
        this.lineName = lineName;
    }

    @Override
    public void run() {
        Axle axle;
        while (axleCount > 0) {
            axleCount--;
            axle = new Axle(lineName, LocalDateTime.now());
            System.out.println("Adding axle: " + axle);
            hopper.addItem(axle);
            try {
                Thread.sleep(500);
            } catch (InterruptedException ie) {
                // ignore for the moment
            }
        }
    }
}

public class AssemblyLine {

    public static void main(String[] args) {
        Hopper<Wheel> wheels = new Hopper<>();
        WheelMaker wheelMaker1 = new WheelMaker(wheels, 20, "Wheel Assembly Line 1");
        WheelMaker wheelMaker2 = new WheelMaker(wheels, 20, "Wheel Assembly Line 2");
        
        Hopper<Axle> axles = new Hopper<>();
        AxleMaker axleMaker = new AxleMaker(axles, 20, "Axle Assembly Line 1");
    }

}

import java.time.LocalDateTime;

public class WheelAssembly {

    private Wheel leftWheel;
    private Wheel rightWheel;
    private Axle axle;
    private String source;
    private LocalDateTime createdDate;
    
    public WheelAssembly(Wheel leftWheel, Wheel rightWheel, Axle axle,
             String source, LocalDateTime createdDate) {
        this.leftWheel = leftWheel;
        this.rightWheel = rightWheel;
        this.axle = axle;
        this.source = source;
        this.createdDate = createdDate;
    }

    @Override
    public String toString() {
        return "WheelAssembly[" + "source=" + source
                + ", created on " + createdDate + ']';
    }

    public Wheel getLeftWheel() {
        return leftWheel;
    }

    public void setLeftWheel(Wheel leftWheel) {
        this.leftWheel = leftWheel;
    }

    public Wheel getRightWheel() {
        return rightWheel;
    }

    public void setRightWheel(Wheel rightWheel) {
        this.rightWheel = rightWheel;
    }

    public Axle getAxle() {
        return axle;
    }

    public void setAxle(Axle axle) {
        this.axle = axle;
    }

    public String getSource() {
        return source;
    }

    public void setSource(String source) {
        this.source = source;
    }

    public LocalDateTime getCreatedDate() {
        return createdDate;
    }

    public void setCreatedDate(LocalDateTime createdDate) {
        this.createdDate = createdDate;
    }

}

import java.time.LocalDateTime;

public class WheelAssemblyMaker implements Runnable {

    private final Hopper<Wheel> wheelHopper;
    private final Hopper<Axle> axleHopper;
    private final Hopper<WheelAssembly> assemblyHopper;
    private int assemblyCount;
    private final String lineName;
    
    public WheelAssemblyMaker(Hopper<Wheel> wheelHopper, Hopper<Axle> axleHopper,
            Hopper<WheelAssembly> assemblyHopper, int assemblyCount, String lineName) {
        this.wheelHopper = wheelHopper;
        this.axleHopper = axleHopper;
        this.assemblyHopper = assemblyHopper;
        this.assemblyCount = assemblyCount;
        this.lineName = lineName;
    }
    
    @Override
    public void run() {
        Axle axle;
        Wheel leftWheel;
        Wheel rightWheel;
        WheelAssembly wheelAssembly;
        while (assemblyCount > 0) {
            assemblyCount--;

            axle = axleHopper.getItem();
            leftWheel = wheelHopper.getItem();
            rightWheel = wheelHopper.getItem();
            wheelAssembly = new WheelAssembly(leftWheel, rightWheel, axle, lineName, LocalDateTime.now());
            System.out.println("Adding wheel assembly: " + wheelAssembly);
            assemblyHopper.addItem(wheelAssembly);
            try {
                Thread.sleep(500);
            } catch (InterruptedException ie) {
                // ignore for the moment
            }
        }
    }

}

import java.util.List;

public class AssemblyLine {

    public static void main(String[] args) {
        Hopper<Wheel> wheels = new Hopper<>();
        WheelMaker wheelMaker1 = new WheelMaker(wheels, 20, "Wheel Production Line 1");
        WheelMaker wheelMaker2 = new WheelMaker(wheels, 20, "Wheel Production Line 2");
        
        Hopper<Axle> axles = new Hopper<>();
        AxleMaker axleMaker = new AxleMaker(axles, 20, "Axle Production Line");
        
        Hopper<WheelAssembly> wheelAssemblies = new Hopper<>();
        WheelAssemblyMaker wheelAssemblyMaker = new WheelAssemblyMaker(wheels, axles, wheelAssemblies, 20, "Assembly Line");

        System.out.println("\nStarting main thread... ");
        try {
            Thread wheel1 = new Thread(wheelMaker1);
            Thread wheel2 = new Thread(wheelMaker2);
            Thread axle1 = new Thread(axleMaker);
            Thread wheelAssemblyThread = new Thread(wheelAssemblyMaker);
            wheel1.start();
            wheel2.start();
            axle1.start();
            wheelAssemblyThread.start();
            wheel1.join();
            wheel2.join();
            axle1.join();
            wheelAssemblyThread.join();
        } catch (InterruptedException ex) {
            System.out.println("Exception: " + ex.getMessage());
        }
        System.out.println("Main thread complete");

        System.out.println("\nPrinting the completed Wheel Assemblies...");
        List<WheelAssembly> assemblies = wheelAssemblies.getList();
        for (WheelAssembly assembly : assemblies) {
            System.out.println("ASSEMBLY:");
            System.out.println("\tSOURCE: " + assembly.getSource());
            System.out.println("\tCREATED ON: " + assembly.getCreatedDate());
            System.out.println("\tAXLE: " + assembly.getAxle());
            System.out.println("\tLEFT WHEEL: " + assembly.getLeftWheel());
            System.out.println("\tRIGHT WHEEL: " + assembly.getRightWheel());
            System.out.println("\t---\n");
        }
        System.out.println("Printing complete.");
    }

}

@Override
public void run() {

    Axle axle;
    Wheel leftWheel;
    Wheel rightWheel;
    WheelAssembly wheelAssembly;
    
    boolean needAxle;
    boolean needLeftWheel;
    boolean needRightWheel;
    while (assemblyCount > 0) {
        // clear the variables
        axle = null;
        leftWheel = null;
        rightWheel = null;
        
        // Get the axle
        needAxle = true;
        
        // Get the leftWheel
        needLeftWheel = true;
        
        // Get the rightWheel
        needRightWheel = true;
    
    }
}

@Override
public void run() {

    Axle axle;
    Wheel leftWheel;
    Wheel rightWheel;
    WheelAssembly wheelAssembly;
    
    boolean needAxle;
    boolean needLeftWheel;
    boolean needRightWheel;
    while (assemblyCount > 0) {
        // clear the variables
        axle = null;
        leftWheel = null;
        rightWheel = null;
        
        // Get the axle
        needAxle = true;
        while (needAxle) {
            axle = axleHopper.getItem();
            if (null == axle) {
                System.out.println(
                        "WheelAssemblyMaker "
                        + lineName
                        + " waiting on an axle."
                );
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException ex) {}
            } else {
                System.out.println(
                        "WheelAssemblyMaker "
                        + lineName
                        + " got axle."
                );
                needAxle = false;
            }
        }
        
        // Get the leftWheel
        needLeftWheel = true;
        while (needLeftWheel) {
            leftWheel = wheelHopper.getItem();
            if (null == leftWheel) {
                System.out.println(
                        "WheelAssemblyMaker "
                        + lineName
                        + " waiting on an left wheel."
                );
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException ex) {}
            } else {
                System.out.println(
                        "WheelAssemblyMaker "
                        + lineName
                        + " got left wheel."
                );
                needLeftWheel = false;
            }
        }
        
        // Get the rightWheel
        needRightWheel = true;
        while (needRightWheel) {
            rightWheel = wheelHopper.getItem();
            if (null == rightWheel) {
                System.out.println(
                        "WheelAssemblyMaker "
                        + lineName
                        + " waiting on an right wheel."
                );
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException ex) {}
            } else {
                System.out.println(
                        "WheelAssemblyMaker "
                        + lineName
                        + " got right wheel."
                );
                needRightWheel = false;
            }
        }
    
    }
}

@Override
public void run() {

    Axle axle;
    Wheel leftWheel;
    Wheel rightWheel;
    WheelAssembly wheelAssembly;
    
    boolean needAxle;
    boolean needLeftWheel;
    boolean needRightWheel;
    while (assemblyCount > 0) {
        // clear the variables
        axle = null;
        leftWheel = null;
        rightWheel = null;
        
        // Get the axle
        needAxle = true;
        while (needAxle) {
            axle = axleHopper.getItem();
            if (null == axle) {
                System.out.println(
                        "WheelAssemblyMaker "
                        + lineName
                        + " waiting on an axle."
                );
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException ex) {}
            } else {
                System.out.println(
                        "WheelAssemblyMaker "
                        + lineName
                        + " got axle."
                );
                needAxle = false;
            }
        }
        
        // Get the leftWheel
        needLeftWheel = true;
        while (needLeftWheel) {
            leftWheel = wheelHopper.getItem();
            if (null == leftWheel) {
                System.out.println(
                        "WheelAssemblyMaker "
                        + lineName
                        + " waiting on an left wheel."
                );
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException ex) {}
            } else {
                System.out.println(
                        "WheelAssemblyMaker "
                        + lineName
                        + " got left wheel."
                );
                needLeftWheel = false;
            }
        }
        
        // Get the rightWheel
        needRightWheel = true;
        while (needRightWheel) {
            rightWheel = wheelHopper.getItem();
            if (null == rightWheel) {
                System.out.println(
                        "WheelAssemblyMaker "
                        + lineName
                        + " waiting on an right wheel."
                );
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException ex) {}
            } else {
                System.out.println(
                        "WheelAssemblyMaker "
                        + lineName
                        + " got right wheel."
                );
                needRightWheel = false;
            }
        }
        wheelAssembly = new WheelAssembly(leftWheel, rightWheel, axle, lineName, LocalDateTime.now());
        System.out.println("Adding wheel assembly: " + wheelAssembly);
        assemblyHopper.addItem(wheelAssembly);
        assemblyCount--;
        try {
            Thread.sleep(500);
        } catch (InterruptedException ie) {
            // ignore for the moment
        }
    
    }
}

public class RequestHandler implements Runnable {

    private Socket socket;

    public RequestHandler(Socket socket) {
        if (null == socket) {
            throw new IllegalArgumentException("Socket cannot be null.");
        }
        this.socket = socket;
    }

    @Override
    public void run() {
        try(
            DataInputStream inputStream = new DataInputStream(socket.getInputStream());
            DataOutputStream outputStream = new DataOutputStream(socket.getOutputStream());
        ) {

            
        } catch (SocketTimeoutException ste) {
            System.out.println("\tSocket connection timed out: "
                    + ste.getMessage());
        } catch (IOException ioe) {
            System.out.println("\tIO Error: " + ioe.getMessage());
        } catch (Exception ex) {
            System.out.println("\tERROR: " + ex.getMessage());
        }
    }

}

public class RequestHandler implements Runnable {

    private Socket socket;

    public RequestHandler(Socket socket) {
        if (null == socket) {
            throw new IllegalArgumentException("Socket cannot be null.");
        }
        this.socket = socket;
    }

    @Override
    public void run() {
        try(
            DataInputStream inputStream = new DataInputStream(socket.getInputStream());
            DataOutputStream outputStream = new DataOutputStream(socket.getOutputStream());
        ) {

            InetAddress inetAddress = socket.getInetAddress();
            String clientAddress = inetAddress.getHostAddress();
            System.out.println("Connection from " + clientAddress);
            
        } catch (SocketTimeoutException ste) {
            System.out.println("\tSocket connection timed out: "
                    + ste.getMessage());
        } catch (IOException ioe) {
            System.out.println("\tIO Error: " + ioe.getMessage());
        } catch (Exception ex) {
            System.out.println("\tERROR: " + ex.getMessage());
        }
    }

}

public class RequestHandler implements Runnable {

    private Socket socket;

    public RequestHandler(Socket socket) {
        if (null == socket) {
            throw new IllegalArgumentException("Socket cannot be null.");
        }
        this.socket = socket;
    }

    @Override
    public void run() {
        try(
            DataInputStream inputStream = new DataInputStream(socket.getInputStream());
            DataOutputStream outputStream = new DataOutputStream(socket.getOutputStream());
        ) {

            InetAddress inetAddress = socket.getInetAddress();
            String clientAddress = inetAddress.getHostAddress();
            System.out.println("Connection from " + clientAddress);
            
            double radius = inputStream.readDouble();
            double area = radius * radius * Math.PI;
            System.out.printf("\tRadius: %10.5f Area: %10.5f\n",
                     radius, area);
                     
            outputStream.writeDouble(area);
            
        } catch (SocketTimeoutException ste) {
            System.out.println("\tSocket connection timed out: "
                    + ste.getMessage());
        } catch (IOException ioe) {
            System.out.println("\tIO Error: " + ioe.getMessage());
        } catch (Exception ex) {
            System.out.println("\tERROR: " + ex.getMessage());
        }
    }

}

public class RequestHandler implements Runnable {

    private Socket socket;

    public RequestHandler(Socket socket) {
        if (null == socket) {
            throw new IllegalArgumentException("Socket cannot be null.");
        }
        this.socket = socket;
    }

    @Override
    public void run() {
        try(
            DataInputStream inputStream = new DataInputStream(socket.getInputStream());
            DataOutputStream outputStream = new DataOutputStream(socket.getOutputStream());
        ) {

            InetAddress inetAddress = socket.getInetAddress();
            String clientAddress = inetAddress.getHostAddress();
            System.out.println("Connection from " + clientAddress);
            
            double radius = inputStream.readDouble();
            double area = radius * radius * Math.PI;
            System.out.printf("\tRadius: %10.5f Area: %10.5f\n",
                     radius, area);
                     
            outputStream.writeDouble(area);
            outputStream.flush();
            
        } catch (SocketTimeoutException ste) {
            System.out.println("\tSocket connection timed out: "
                    + ste.getMessage());
        } catch (IOException ioe) {
            System.out.println("\tIO Error: " + ioe.getMessage());
        } catch (Exception ex) {
            System.out.println("\tERROR: " + ex.getMessage());
        }
    }

}

public class CircleAreaServer {

    public static void main(String[] args) {

        int port = 5555;
        int threadCount = 100;
        int timeoutLength = 3000;

    }

}

public class CircleAreaServer {

    public static void main(String[] args) {

        int port = 5555;
        int threadCount = 100;
        int timeoutLength = 3000;

        ExecutorService executorService = Executors.newFixedThreadPool(threadCount);

    }

}

public class CircleAreaServer {

    public static void main(String[] args) {

        int port = 5555;
        int threadCount = 100;
        int timeoutLength = 3000;

        ExecutorService executorService = Executors.newFixedThreadPool(threadCount);

        try{
            ServerSocket serverSocket = new ServerSocket(port);
            System.out.printf("ServerSocket listening on port %d\n", port);

            

        } catch (IOException ex) {
            System.out.println("CATASTROPHIC FAILURE:  Server Stopping!");
            System.out.println(ex.getMessage());
        }
    }

}

public class CircleAreaServer {

    public static void main(String[] args) {

        int port = 5555;
        int threadCount = 100;
        int timeoutLength = 3000;

        ExecutorService executorService = Executors.newFixedThreadPool(threadCount);

        try{
            ServerSocket serverSocket = new ServerSocket(port);
            System.out.printf("ServerSocket listening on port %d\n", port);

            Socket socket;
            while(true){
                socket = serverSocket.accept();
                socket.setSoTimeout(timeoutLength);
                
            }

        } catch (IOException ex) {
            System.out.println("CATASTROPHIC FAILURE:  Server Stopping!");
            System.out.println(ex.getMessage());
        }
    }

}

public class CircleAreaServer {

    public static void main(String[] args) {

        int port = 5555;
        int threadCount = 100;
        int timeoutLength = 3000;

        ExecutorService executorService = Executors.newFixedThreadPool(threadCount);

        try{
            ServerSocket serverSocket = new ServerSocket(port);
            System.out.printf("ServerSocket listening on port %d\n", port);

            Socket socket;
            while(true){
                socket = serverSocket.accept();
                socket.setSoTimeout(timeoutLength);
                executorService.execute(new RequestHandler(socket));
            }

        } catch (IOException ex) {
            System.out.println("CATASTROPHIC FAILURE:  Server Stopping!");
            System.out.println(ex.getMessage());
        }
    }

}

public class CircleAreaClient {
    
    private static String getUserInput(String prompt){
        System.out.print(prompt + " ");
        return new Scanner(System.in).nextLine();
    }
    
    public static void main(String[] args) {

        String response;
        String prompt = "Enter the radius of a circle or Q to quit:";
        boolean keepGoing = true;
        while(keepGoing){
            response = getUserInput(prompt);
            if(response.equalsIgnoreCase("Q")){
                keepGoing = false;
            } else {
                try{
                    double radius = Double.parseDouble(response);
                    
                } catch(NumberFormatException nfe){
                    System.out.printf("ERROR: [%s] is not a number!\n", response);
                    System.out.println("Please try again.\n");
                }
            }
        }
        System.out.println("\nProgram complete.");
    }

}

public class CircleAreaClient {

    private static final int PORT = 5555;
    private static final String HOST_NAME = "localhost";
    
    private static double getAreaFromServer(double radius) throws UnknownHostException, IOException {
        Socket socket = new Socket(HOST_NAME, PORT);
        DataInputStream inputStream = new DataInputStream(socket.getInputStream());
        DataOutputStream outputStream = new DataOutputStream(socket.getOutputStream());
        outputStream.writeDouble(radius);
        outputStream.flush();
        double area = inputStream.readDouble();
        inputStream.close();
        outputStream.close();
        return area;
    }
    
    private static String getUserInput(String prompt){
        System.out.print(prompt + " ");
        return new Scanner(System.in).nextLine();
    }
    
    public static void main(String[] args) {

        String response;
        String prompt = "Enter the radius of a circle or Q to quit:";
        boolean keepGoing = true;
        while(keepGoing){
            response = getUserInput(prompt);
            if(response.equalsIgnoreCase("Q")){
                keepGoing = false;
            } else {
                try{
                    double radius = Double.parseDouble(response);
                    try{
                        double area = getAreaFromServer(radius);
                        System.out.printf("The area from the server is %f\n", area);
                    } catch(UnknownHostException uhe){
                        System.out.println("ERROR: " + uhe.getMessage());
                        System.out.println("Program terminating!");
                        System.exit(-1);
                    } catch(IOException ioe) {
                        System.out.println("ERROR: " + ioe.getMessage());
                    }
                } catch(NumberFormatException nfe){
                    System.out.printf("ERROR: [%s] is not a number!\n", response);
                    System.out.println("Please try again.\n");
                }
            }
        }
        System.out.println("\nProgram complete.");
    }

}

public class Widget {
    private int value;
    private String name;

    public Widget(int value, String name) {
        this.value = value;
        this.name = name;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

public class Main {
    
    // STEP 5A: Do a Google search for how to generate a String of random letters.
        // Write that code in a separate method here. Cite your source in a comment.
        // Be sure the String is returned in all capital letters.
    // End the method here
    
    public static void main(String[] args) {
        // STEP 1: instantitate an ArrayList of Widgets here
        
        // STEP 3: Create a Supplier Functional Interface. It will take no arguments and return a Widget.
            // STEP 4: Assign a random int value from -10 to 90 to a variable.
            // STEP 5B: Call the random string method here and assign the returned value to a variable. 
            // STEP 6: Instantiate a new Widget object and return it.
        // End the Supplier here
        
        // STEP 8: Create a Predicate Functional Interface to test if a Widget's value is zero or greater here.
            // This will take a single Widget as input, use the .getValue() method, and return a boolean.
            // This code should be written on a single line.
            
        // STEP 10: Create a UnaryOperator Functional Interface to convert the Widget name to all lowercase letters here.
            // This will take a single Widget as input, use both the .getName() and .setName() methods, and return the updated Widget.
            // This code should be written on a single line.
        
        // STEP 13: Create a Consumer Functional Interface to print each Widget as a string on a new line.
            // This will take a single widget as input, use the .getValue() and .getName() methods, and print each Widget.
            // This code should be written on a single line.
            
        // STEP 2: Create a loop that runs 20 times
            // STEP 7: Use the Supplier .get() method to instantitate a Widget object
            // STEP 9: Write an if statement that uses the Predicate .test() method as the condition.
                // STEP 11: If true, use the UnaryOperator .apply() method. Take the resulting Widget and add it to the ArrayList.
            // End the if statement here
        // End the loop here
                
        // STEP 12: Use a .forEach() method to iterate through each widget in the ArrayList.
            // STEP 14: Use the Consumer .accept() method.
        
    }
    
}