package com.it_jaros.networkScanner;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketException;
import java.net.SocketTimeoutException;
import java.util.ArrayList;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.LockSupport;

public class Scanner {
                
    private final Counter counter = new Counter();
    private final ProgressBar progressBar = new ProgressBar();
    private final Semaphore socketLimit;
    private final int timeoutInMillis;
    private final long delayInNanos;
    
    public Scanner(int socketLimit, int timeoutInMillis, int delayInMillis) {
        this.timeoutInMillis = timeoutInMillis;
        this.delayInNanos = TimeUnit.MILLISECONDS.toNanos(Math.max(0, delayInMillis));
        this.socketLimit = new Semaphore(socketLimit);
    }

    public List<ScanResult> scan(ScanOptions target) {
        return scanTargets(target.targets(), target.ports());
    }

    public List<ScanResult> scanTargets(List<String> targets, String ports) {
        List<ScanResult> results = new ArrayList<>();
        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();) {
            List<Progress> progresses = new ArrayList<>();
            for (String target : targets) {
                ScanResult result = scanTargetPorts(target, ports, executor);
                results.add(result);
                progresses.add(result.progress());
            }
            progressBar.start(progresses);
        }

        progressBar.stop();
        System.out.println("Peak concurrent connects: " + counter.max());
        return results;
    }

    private ScanResult scanTargetPorts(String target, String ports, ExecutorService executor) {
        PortRange portRange = new PortRange(ports);
        Progress progress = new Progress(target, portRange.getTotal(), new AtomicInteger(),
                new AtomicInteger());
        AtomicLong scanSlotFactory = new AtomicLong(System.nanoTime());
        Queue<Integer> openPorts = new ConcurrentLinkedQueue<>();
        while (portRange.hasNext()) {
            final int currentPort = portRange.next();
            executor.submit(() -> {
                try {
                    waitForSlot(scanSlotFactory);
                    if (isTargetPortOpen(target, currentPort)) {
                        openPorts.add(currentPort);
                        progressBar.onPortOpen(progress);
                    }
                } finally {
                    progressBar.onPortFinished(progress);
                }
            });
        }
        return new ScanResult(target, openPorts, progress);
    }

    private void waitForSlot(AtomicLong scanSlotFactory) {
        if (delayInNanos > 0) {
            long slot = scanSlotFactory.getAndAdd(delayInNanos);
            long wait = slot - System.nanoTime();
            if (wait > 0)
                LockSupport.parkNanos(wait);
        }
    }

    private boolean isTargetPortOpen(String target, int port) {
        socketLimit.acquireUninterruptibly();
        counter.inc();
        try (Socket socket = new Socket()) {
            socket.connect(new InetSocketAddress(target, port), timeoutInMillis);
            return true;
        } catch (SocketException | SocketTimeoutException ignored) {
        } catch (IOException e) {
            System.out.println(e.getClass().getSimpleName() + ": " + e.getMessage());
        } finally {
            counter.dec();
            socketLimit.release();
        }

        return false;
    }
}