import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;

public class ReentrantLockFinally {
    
    private final ReentrantLock lock = new ReentrantLock();
    
    //Антипаттерн: без finally — риск deadlock
    public void badMethod() {
        lock.lock();
        // Если здесь произойдет исключение, lock не освободится
        doWork();
        lock.unlock(); // Может не выполниться
    }
    
    //Правильно: try-finally
    public void goodMethod() {
        lock.lock();
        try {
            doWork();
        } finally {
            lock.unlock(); // Гарантированно вызовется
        }
    }
    
    //tryLock с таймаутом
    public boolean tryLockWithTimeout() throws InterruptedException {
        if (lock.tryLock(1, TimeUnit.SECONDS)) {
            try {
                doWork();
                return true;
            } finally {
                lock.unlock();
            }
        } else {
            System.out.println("Не удалось захватить блокировку");
            return false;
        }
    }
    
    //Использование Condition (тоже с finally)
    public void conditionExample() throws InterruptedException {
        var condition = lock.newCondition();
        lock.lock();
        try {
            condition.await(1, TimeUnit.SECONDS);
        } finally {
            lock.unlock();
        }
    }
    
    private void doWork() {
        // критическая секция
    }
}

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;

public class Task080726 {
    private static final ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            lock.lock();
            System.out.println("Thread1 acquired lock");
        });

        Thread t2 = new Thread(() -> {
            try {
                if (lock.tryLock(1, TimeUnit.SECONDS)) {
                    System.out.println("Thread2 acquired lock");
                    lock.unlock();
                } else {
                    System.out.println("Thread2 failed to acquire lock");
                }
            } catch (InterruptedException e) {
                System.out.println("Interrupted");
            }
        });

        t1.start();
        Thread.sleep(100);
        t2.start();
        t2.join();
    }
}

java.io.File oldFile = new java.io.File("/etc/shadow");
boolean deleted = oldFile.delete();  // false — но почему? Нет прав? Файл занят? Файла нет?

Path configPath = Paths.get("/app/config.properties");
boolean exists = Files.exists(configPath);

Path secret = Paths.get("/root/.ssh/id_rsa");

if (Files.notExists(secret)) {
    // Мы уверены, что файла нет (или нет прав, но тогда exists тоже вернул бы false)
    System.out.println("Файл не существует");
} else if (Files.exists(secret)) {
    // Мы уверены, что файл есть
    System.out.println("Файл существует");
} else {
    // Files.exists() == false И Files.notExists() == false
    // Это возможно только при ошибке доступа — состояние неопределённости
    System.out.println("Невозможно определить существование файла");
}

Path dir = Paths.get("/var/log");
if (Files.isDirectory(dir)) {
    // Это директория
}

Path file = Paths.get("/etc/passwd");
if (Files.isRegularFile(file)) {
    // Это обычный файл, можно безопасно читать
}

Path link = Paths.get("/usr/bin/java");
if (Files.isSymbolicLink(link)) {
    Path target = Files.readSymbolicLink(link);  // куда указывает ссылка
    System.out.println("Ссылка ведёт на: " + target);
}

import java.nio.file.*;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class ConfigInitializer {
    
    private static final Path CONFIG_PATH = Paths.get("app.conf");
    private static final String DEFAULT_CONFIG = 
        "# Default configuration\n" +
        "server.port=8080\n" +
        "db.url=jdbc:h2:mem:test\n";
    
    public void initialize() throws IOException {
        // Шаг 1: проверяем, существует ли путь
        if (Files.notExists(CONFIG_PATH)) {
            // Файла точно нет — создаём с дефолтами
            createDefaultConfig();
            System.out.println("Конфигурация создана по умолчанию");
            return;
        }
        
        // Шаг 2: файл существует — проверяем, что это обычный файл
        if (!Files.isRegularFile(CONFIG_PATH)) {
            if (Files.isDirectory(CONFIG_PATH)) {
                throw new IOException(
                    "Конфигурационный путь \"" + CONFIG_PATH + "\" является директорией"
                );
            }
            if (Files.isSymbolicLink(CONFIG_PATH)) {
                // Разрешаем символическую ссылку, но проверяем целевой объект
                Path target = Files.readSymbolicLink(CONFIG_PATH);
                if (!Files.isRegularFile(target, LinkOption.NOFOLLOW_LINKS)) {
                    throw new IOException(
                        "Символическая ссылка конфигурации указывает на не-файл: " + target
                    );
                }
                // Ссылка валидна — продолжаем
                return;
            }
            throw new IOException("Неизвестный тип файла конфигурации");
        }
        
        // Шаг 3: обычный файл существует — проверяем читаемость
        if (!Files.isReadable(CONFIG_PATH)) {
            throw new AccessDeniedException("Нет прав на чтение конфигурации");
        }
        
        System.out.println("Конфигурация загружена из существующего файла");
    }
    
    private void createDefaultConfig() throws IOException {
        // getParent() может вернуть null, если путь в текущей директории
        Path parent = CONFIG_PATH.getParent();
        if (parent != null && Files.notExists(parent)) {
            // createDirectories создаёт всю иерархию, включая промежуточные директории
            Files.createDirectories(parent);
        }
        // write записывает массив байтов в файл, создавая его атомарно
        Files.write(CONFIG_PATH, DEFAULT_CONFIG.getBytes(StandardCharsets.UTF_8));
    }
}

// try-with-resources гарантирует вызов close() даже при исключении
// AutoCloseable — интерфейс, требующий реализации метода close()
try (InputStream in = Files.newInputStream(path)) {
    // работа с потоком
}  // close() вызывается автоматически здесь

// Чтение всего файла как массива байтов
byte[] rawData = Files.readAllBytes(Paths.get("data.bin"));

// Чтение текстового файла в список строк
List<String> lines = Files.readAllLines(
    Paths.get("log.txt"), 
    StandardCharsets.UTF_8
);

// Stream<String> должен быть закрыт, так как держит файловый дескриптор
try (Stream<String> stream = Files.lines(Paths.get("huge.log"))) {
    long errorCount = stream.filter(line -> line.contains("ERROR")).count();
}

Path target = Paths.get("output.txt");
byte[] data = "Hello, World".getBytes(StandardCharsets.UTF_8);

// CREATE — создать файл, если не существует
// TRUNCATE_EXISTING — очистить существующий файл перед записью
Files.write(target, data, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);

Path src = Paths.get("/tmp/source.dat");
Path dst = Paths.get("/backup/source.dat");

Files.copy(src, dst, 
    StandardCopyOption.REPLACE_EXISTING,  // перезаписать, если есть
    StandardCopyOption.COPY_ATTRIBUTES    // скопировать права и временные метки
);

Files.move(src, dst, StandardCopyOption.ATOMIC_MOVE);

// delete бросает NoSuchFileException, если файла нет
Files.delete(Paths.get("temp.tmp"));

// deleteIfExists возвращает boolean, не бросая исключение при отсутствии
boolean deleted = Files.deleteIfExists(Paths.get("temp.tmp"));

// walk возвращает Stream<Path> всех файлов и директорий, начиная с root
// sorted(Comparator.reverseOrder()) — сначала файлы, потом родительские директории
Files.walk(root)
     .sorted(Comparator.reverseOrder())
     .forEach(p -> {
         try {
             Files.delete(p);
         } catch (IOException e) {
             throw new UncheckedIOException(e);
         }
     });

// Чтение произвольного атрибута файловой системы
Object creationTime = Files.getAttribute(path, "creationTime");

// Установка POSIX-прав доступа (только на Unix)
Set<PosixFilePermission> perms = PosixFilePermissions.fromString("rw-r--r--");
Files.setPosixFilePermissions(path, perms);

FileStore store = Files.getFileStore(path);
long usableSpace = store.getUsableSpace();
long totalSpace = store.getTotalSpace();

public void atomicWrite(Path target, byte[] data) throws IOException {
    // Создаём временный файл в той же директории, что и target
    // это важно, чтобы move был атомарным в пределах одного FileStore
    Path temp = Files.createTempFile(target.getParent(), "tmp_", ".dat");
    try {
        Files.write(temp, data);
        // Атомарное переименование: либо старый файл заменён, либо нет
        Files.move(temp, target, StandardCopyOption.ATOMIC_REPLACE);
    } catch (IOException e) {
        // При ошибке удаляем временный файл
        Files.deleteIfExists(temp);
        throw e;
    }
}

WatchService watchService = FileSystems.getDefault().newWatchService();
Path dir = Paths.get("/app/inbox");

// Регистрируем директорию на отслеживание создания и модификации файлов
dir.register(watchService, 
    StandardWatchEventKinds.ENTRY_CREATE,
    StandardWatchEventKinds.ENTRY_MODIFY
);

// WatchService — механизм мониторинга изменений в файловой системе
// Он использует нативные API ОС (inotify на Linux, FSEvents на macOS, ReadDirectoryChangesW на Windows)

import java.nio.file.*;
import java.io.IOException;

public class Task090726 {
    public static void main(String[] args) throws IOException {
        Path p1 = Paths.get("");
        Path p2 = Paths.get(".");
        System.out.println(Files.isSameFile(p1, p2));
        System.out.println(p1.equals(p2));
        System.out.println(p1.normalize().equals(p2.normalize()));
    }
}

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class SpuriousWakeup {
    
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    private boolean ready = false;
    
    //Антипаттерн: if вместо цикла
    public void badAwait() throws InterruptedException {
        lock.lock();
        try {
            if (!ready) {
                condition.await(); // Может проснуться ложно
            }
            // Здесь ready может быть false!
            doWork();
        } finally {
            lock.unlock();
        }
    }
    
    //Правильно: while цикл
    public void goodAwait() throws InterruptedException {
        lock.lock();
        try {
            while (!ready) {
                condition.await(); // Проверка в цикле
            }
            // Теперь ready гарантированно true
            doWork();
        } finally {
            lock.unlock();
        }
    }
    
    // Сигнал для изменения состояния
    public void signal() {
        lock.lock();
        try {
            ready = true;
            condition.signal();
        } finally {
            lock.unlock();
        }
    }
    
    // Демонстрация с несколькими потоками
    public static void main(String[] args) throws InterruptedException {
        SpuriousWakeup demo = new SpuriousWakeup();
        
        Thread waiter = new Thread(() -> {
            try {
                demo.goodAwait();
                System.out.println("Проснулся корректно");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        
        waiter.start();
        Thread.sleep(100);
        demo.signal(); // Разбудим
        waiter.join();
    }
}

import java.util.concurrent.locks.*;
import java.util.concurrent.TimeUnit;

public class Task100726 {
    private static final Lock lock = new ReentrantLock();
    private static final Condition condition = lock.newCondition();
    private static volatile boolean flag = false;

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            lock.lock();
            try {
                if (!flag) {
                    condition.await(3, TimeUnit.SECONDS);
                }
                System.out.print("Done");
            } catch (InterruptedException e) {
                System.out.print("Interrupted");
            } finally {
                lock.unlock();
            }
        });
        t.start();
        t.join();
    }
}