import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

class StoreTest {
    private Store store;
    private Customer customer;

    @BeforeEach
    void setUp() {
        store = new Store();
        customer = new Customer();
    }

    // 在庫が十分にある場合、購入は成功する
    @Test
    void purchaseSucceedsWhenEnoughInventory() {
        // 準備 (Arrange)
        store.addInventory(Product.SHAMPOO, 10);

        // 実行 (Act)
        boolean success = customer.purchase(store, Product.SHAMPOO, 5);

        // 確認 (Assert)
        assertTrue(success);
        assertEquals(5, store.getInventory(Product.SHAMPOO)); // 店にある商品数が「5」に減っていること
    }

    // 在庫が足りない場合、購入は失敗する
    @Test
    void purchaseFailsWhenNotEnoughInventory() {
        // 準備 (Arrange)
        store.addInventory(Product.SHAMPOO, 10);

        // 実行 (Act)
        boolean success = customer.purchase(store, Product.SHAMPOO, 15);

        // 確認 (Assert)
        assertFalse(success);
        assertEquals(10, store.getInventory(Product.SHAMPOO)); // 店の商品数が変わっていないこと
    }
}

// 商品の種類
enum Product {
    SHAMPOO,
    BOOK
}

// シンプルな Store クラス（在庫管理）
class Store {
    private final java.util.Map<Product, Integer> inventory = new java.util.HashMap<>();

    public void addInventory(Product product, int quantity) {
        inventory.put(product, inventory.getOrDefault(product, 0) + quantity);
    }

    public int getInventory(Product product) {
        return inventory.getOrDefault(product, 0);
    }

    public boolean purchase(Product product, int quantity) {
        int stock = getInventory(product);
        if (stock >= quantity) {
            inventory.put(product, stock - quantity);
            return true;
        }
        return false;
    }
}

// シンプルな Customer クラス
class Customer {
    public boolean purchase(Store store, Product product, int quantity) {
        return store.purchase(product, quantity);
    }
}

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;

class StoreTest {
    private IStore storeMock;
    private Customer customer;

    @BeforeEach
    void setUp() {
        storeMock = mock(IStore.class);
        customer = new Customer();
    }

    // 在庫が十分にある場合、購入は成功する
    @Test
    void purchaseSucceedsWhenEnoughInventory() {
        // 準備 (Arrange)
        when(storeMock.hasEnoughInventory(Product.SHAMPOO, 5)).thenReturn(true);

        // 実行 (Act)
        boolean success = customer.purchase(storeMock, Product.SHAMPOO, 5);

        // 確認 (Assert)
        assertTrue(success);
        verify(storeMock, times(1)).removeInventory(Product.SHAMPOO, 5); // removeInventoryが一度呼ばれる
    }

    // 在庫が足りない場合、購入は失敗する
    @Test
    void purchaseFailsWhenNotEnoughInventory() {
        // 準備 (Arrange)
        when(storeMock.hasEnoughInventory(Product.SHAMPOO, 5)).thenReturn(false);

        // 実行 (Act)
        boolean success = customer.purchase(storeMock, Product.SHAMPOO, 5);

        // 確認 (Assert)
        assertFalse(success);
        verify(storeMock, never()).removeInventory(Product.SHAMPOO, 5); // removeInventoryは呼ばれない
    }
}

// 商品の種類
enum Product {
    SHAMPOO,
    BOOK
}

// Store インターフェース（モック対象）
interface IStore {
    boolean hasEnoughInventory(Product product, int quantity);
    void removeInventory(Product product, int quantity);
}

// Customer クラス（テスト対象）
class Customer {
    public boolean purchase(IStore store, Product product, int quantity) {
        if (store.hasEnoughInventory(product, quantity)) {
            store.removeInventory(product, quantity);
            return true;
        }
        return false;
    }
}

import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;

class Calculator {
    public double sum(double a, double b) {
        return a + b;
    }
}

class CalculatorTest {

    @Test
    void sum_of_two_numbers() {
        Calculator calculator = new Calculator();
        double result = calculator.sum(10, 20);
        
        assertThat(result).isEqualTo(30);
    }
}

import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;

class StoreTest {

    @Test
    void purchaseFailsWhenNotEnoughInventory() {
        // モックの作成
        Store storeMock = mock(Store.class);
        
        // モックの動作設定
        when(storeMock.hasEnoughInventory(Product.SHAMPOO, 5)).thenReturn(false);

        Customer sut = new Customer();

        // メソッドの実行
        boolean success = sut.purchase(storeMock, Product.SHAMPOO, 5);

        // 検証
        assertFalse(success);
        verify(storeMock, never()).removeInventory(Product.SHAMPOO, 5);
    }
}

import java.io.IOException;
import java.nio.file.*;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.stream.Collectors;

public class AuditManager {
    private final int maxEntriesPerFile;
    private final String directoryName;

    public AuditManager(int maxEntriesPerFile, String directoryName) {
        this.maxEntriesPerFile = maxEntriesPerFile;
        this.directoryName = directoryName;
    }

    public void addRecord(String visitorName, String timeOfVisit) throws IOException {
        // 訪問者記録ファイルのディレクトリから全てのファイルパスを取得
        // ファイル名に含まれるインデックスで並び替え
        List<Path> filePaths = Files.list(Paths.get(directoryName))
                                    .filter(Files::isRegularFile)
                                    .sorted((p1, p2) -> {
                                        String name1 = p1.getFileName().toString();
                                        String name2 = p2.getFileName().toString();
                                        return name1.compareTo(name2);
                                    })
                                    .collect(Collectors.toList());

        String newRecord = visitorName + ", " + timeOfVisit;

        // 訪問者記録ファイルが未作成なら新規ファイルを作成して記録する
        if (filePaths.isEmpty()) {
            String newFile = Paths.get(directoryName, "audit_1.txt").toString();
            Files.writeString(Paths.get(newFile), newRecord, StandardCharsets.UTF_8);
            return;
        }

        Path currentFilePath = filePaths.get(filePaths.size() - 1);
        List<String> lines = Files.readAllLines(currentFilePath, StandardCharsets.UTF_8);

        // 記録可能な訪問者の上限数に達しているかを確認
        if (lines.size() < maxEntriesPerFile) {
            // 上限未達の場合は新たな訪問者の記録を追加
            lines.add(newRecord);
            Files.write(currentFilePath, lines, StandardCharsets.UTF_8);
        } else {
            // 新規ファイルを作成して記録を追加
            int newIndex = filePaths.size() + 1;
            String newName = "audit_" + newIndex + ".txt";
            String newFile = Paths.get(directoryName, newName).toString();
            Files.writeString(Paths.get(newFile), newRecord, StandardCharsets.UTF_8);
        }
    }
}

import java.io.IOException;
import java.nio.file.*;
import java.util.List;
import java.util.stream.Collectors;

public interface IFileSystem {
    List<String> getFiles(String directoryName) throws IOException;
    void writeAllText(String filePath, String content) throws IOException;
    List<String> readAllLines(String filePath) throws IOException;
}

class DefaultFileSystem implements IFileSystem {
    @Override
    public List<String> getFiles(String directoryName) throws IOException {
        try (var stream = Files.list(Paths.get(directoryName))) {
            return stream.map(Path::toString).collect(Collectors.toList());
        }
    }

    @Override
    public void writeAllText(String filePath, String content) throws IOException {
        Files.writeString(Paths.get(filePath), content);
    }

    @Override
    public List<String> readAllLines(String filePath) throws IOException {
        return Files.readAllLines(Paths.get(filePath));
    }
}

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

public class AuditManager {
    private final int maxEntriesPerFile;
    private final String directoryName;
    private final IFileSystem fileSystem;

    public AuditManager(int maxEntriesPerFile, String directoryName, IFileSystem fileSystem) {
        this.maxEntriesPerFile = maxEntriesPerFile;
        this.directoryName = directoryName;
        this.fileSystem = fileSystem;
    }

    public void addRecord(String visitorName, String timeOfVisit) throws IOException {
        List<String> filePaths = fileSystem.getFiles(directoryName);
        List<String> sorted = filePaths.stream().sorted().toList();

        String newRecord = visitorName + ";" + timeOfVisit;

        if (sorted.isEmpty()) {
            String newFile = Path.of(directoryName, "audit_1.txt").toString();
            fileSystem.writeAllText(newFile, newRecord);
            return;
        }

        String currentFilePath = sorted.get(sorted.size() - 1);
        List<String> lines = fileSystem.readAllLines(currentFilePath);

        if (lines.size() < maxEntriesPerFile) {
            lines.add(newRecord);
            String newContent = String.join("\n", lines);
            fileSystem.writeAllText(currentFilePath, newContent);
        } else {
            int newIndex = sorted.size() + 1;
            String newFile = Path.of(directoryName, "audit_" + newIndex + ".txt").toString();
            fileSystem.writeAllText(newFile, newRecord);
        }
    }
}

import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;

import java.io.IOException;
import java.util.List;

class AuditManagerTest {
    @Test
    void testNewFileIsCreatedWhenCurrentFileOverflows() throws IOException {
        IFileSystem fileSystemMock = mock(IFileSystem.class);

        when(fileSystemMock.getFiles("audits"))
            .thenReturn(List.of("audits/audit_1.txt", "audits/audit_2.txt"));

        when(fileSystemMock.readAllLines("audits/audit_2.txt"))
            .thenReturn(List.of(
                "Peter;2019-04-06T16:30:00",
                "Jane;2019-04-06T16:40:00",
                "Jack;2019-04-06T17:00:00"
            ));

        AuditManager sut = new AuditManager(3, "audits", fileSystemMock);

        sut.addRecord("Alice", "2019-04-06T18:00:00");

        verify(fileSystemMock).writeAllText(
            "audits/audit_3.txt",
            "Alice;2019-04-06T18:00:00"
        );
    }
}

import java.nio.file.*;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.*;

public class AuditManager {
    private final int maxEntriesPerFile;

    public AuditManager(int maxEntriesPerFile) {
        this.maxEntriesPerFile = maxEntriesPerFile;
    }

    public FileUpdate addRecord(FileContent[] files, String visitorName, LocalDateTime timeOfVisit) {
        List<Map.Entry<Integer, FileContent>> sorted = sortByIndex(files);

        String newRecord = visitorName + ";" + timeOfVisit;

        if (sorted.isEmpty()) {
            return new FileUpdate("audit_1.txt", newRecord);
        }

        Map.Entry<Integer, FileContent> current = sorted.get(sorted.size() - 1);
        List<String> lines = new ArrayList<>(List.of(current.getValue().getLines()));

        if (lines.size() < maxEntriesPerFile) {
            lines.add(newRecord);
            String newContent = String.join("\r\n", lines);
            return new FileUpdate(current.getValue().getFileName(), newContent);
        } else {
            int newIndex = current.getKey() + 1;
            String newName = "audit_" + newIndex + ".txt";
            return new FileUpdate(newName, newRecord);
        }
    }

    private List<Map.Entry<Integer, FileContent>> sortByIndex(FileContent[] files) {
        return IntStream.range(0, files.length)
                .mapToObj(i -> Map.entry(i, files[i]))
                .sorted(Comparator.comparingInt(Map.Entry::getKey))
                .collect(Collectors.toList());
    }
}

class FileContent {
    private final String fileName;
    private final String[] lines;

    public FileContent(String fileName, String[] lines) {
        this.fileName = fileName;
        this.lines = lines;
    }

    public String getFileName() {
        return fileName;
    }

    public String[] getLines() {
        return lines;
    }
}

class FileUpdate {
    private final String fileName;
    private final String newContent;

    public FileUpdate(String fileName, String newContent) {
        this.fileName = fileName;
        this.newContent = newContent;
    }

    public String getFileName() {
        return fileName;
    }

    public String getNewContent() {
        return newContent;
    }
}

class Persister {
    public FileContent[] readDirectory(String directoryName) throws IOException {
        return Files.list(Paths.get(directoryName))
                .map(path -> {
                    try {
                        return new FileContent(path.getFileName().toString(), Files.readAllLines(path).toArray(new String[0]));
                    } catch (IOException e) {
                        throw new UncheckedIOException(e);
                    }
                })
                .toArray(FileContent[]::new);
    }

    public void applyUpdate(String directoryName, FileUpdate update) throws IOException {
        Path filePath = Paths.get(directoryName, update.getFileName());
        Files.write(filePath, update.getNewContent().getBytes());
    }
}

class ApplicationService {
    private final String directoryName;
    private final AuditManager auditManager;
    private final Persister persister;

    public ApplicationService(String directoryName, int maxEntriesPerFile) {
        this.directoryName = directoryName;
        this.auditManager = new AuditManager(maxEntriesPerFile);
        this.persister = new Persister();
    }

    public void addRecord(String visitorName, LocalDateTime timeOfVisit) throws IOException {
        FileContent[] files = persister.readDirectory(directoryName);
        FileUpdate update = auditManager.addRecord(files, visitorName, timeOfVisit);
        persister.applyUpdate(directoryName, update);
    }
}

import org.junit.jupiter.api.Test;
import java.time.LocalDateTime;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class AuditManagerTest {

    @Test
    public void aNewFileIsCreatedWhenTheCurrentFileOverflows() {
        AuditManager sut = new AuditManager(3);
        FileContent[] files = new FileContent[] {
            new FileContent("audit_1.txt", new String[0]),
            new FileContent("audit_2.txt", new String[] {
                "Peter;2019-04-06T16:30:00",
                "Jane;2019-04-06T16:40:00",
                "Jack;2019-04-06T17:00:00"
            })
        };

        FileUpdate update = sut.addRecord(
            files, "Alice", LocalDateTime.parse("2019-04-06T18:00:00"));

        assertEquals("audit_3.txt", update.getFileName());
        assertEquals("Alice;2019-04-06T18:00:00", update.getNewContent());
    }
}

public class User {
    private int userId;
    private String email;
    private UserType type;

    public int getUserId() {
        return userId;
    }

    public String getEmail() {
        return email;
    }

    public UserType getType() {
        return type;
    }

    public void changeEmail(int userId, String newEmail) {
        Object[] data = Database.getUserById(userId); // 指定したユーザのメールアドレスと種類をデータベースから取得する
        this.userId = userId;
        this.email = (String) data[1];
        this.type = (UserType) data[2];

        if (email.equals(newEmail)) {
            return;
        }

        Object[] companyData = Database.getCompany(); // 会社のドメイン名と従業員数を取得する
        String companyDomainName = (String) companyData[0];
        int numberOfEmployees = (int) companyData[1];

        String emailDomain = newEmail.split("@")[1];
        boolean isEmailCorporate = emailDomain.equals(companyDomainName);
        UserType newType = isEmailCorporate ? UserType.Employee : UserType.Customer; // メールアドレスに含まれるドメイン名をもとにユーザの種類を決める

        if (type != newType) {
            int delta = newType == UserType.Employee ? 1 : -1;
            int newNumber = numberOfEmployees + delta;
            Database.saveCompany(newNumber); // 必要に応じて従業員数を更新する
        }

        this.email = newEmail;
        this.type = newType;

        Database.saveUser(this); // ユーザの情報をデータベースに保存する
        MessageBus.sendEmailChangedMessage(userId, newEmail); // メッセージバスにメッセージを送る
    }
}

enum UserType {
    Customer(1),
    Employee(2);

    private final int value;

    UserType(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }
}

class Database {
    public static Object[] getUserById(int userId) {
        // Implement database retrieval logic
        return new Object[]{};
    }

    public static Object[] getCompany() {
        // Implement database retrieval logic
        return new Object[]{};
    }

    public static void saveCompany(int newNumber) {
        // Implement database save logic
    }

    public static void saveUser(User user) {
        // Implement database save logic
    }
}

class MessageBus {
    public static void sendEmailChangedMessage(int userId, String newEmail) {
        // Implement message sending logic
    }
}

public class UserController {
    private final Database database = new Database();
    private final MessageBus messageBus = new MessageBus();

    public void changeEmail(int userId, String newEmail) {
        Object[] data = database.getUserById(userId);
        String email = (String) data[1];
        UserType type = (UserType) data[2];
        User user = new User(userId, email, type);

        Object[] companyData = database.getCompany();
        String companyDomainName = (String) companyData[0];
        int numberOfEmployees = (int) companyData[1];

        int newNumberOfEmployees = user.changeEmail(
            newEmail, companyDomainName, numberOfEmployees);

        database.saveCompany(newNumberOfEmployees);
        database.saveUser(user);
        messageBus.sendEmailChangedMessage(userId, newEmail);
    }
}

class User {
    private int userId;
    private String email;
    private UserType type;

    public User(int userId, String email, UserType type) {
        this.userId = userId;
        this.email = email;
        this.type = type;
    }

    public int changeEmail(String newEmail, String companyDomainName, int numberOfEmployees) {
        if (email.equals(newEmail)) {
            return numberOfEmployees;
        }

        String emailDomain = newEmail.split("@")[1];
        boolean isEmailCorporate = emailDomain.equals(companyDomainName);
        UserType newType = isEmailCorporate ? UserType.Employee : UserType.Customer;

        if (type != newType) {
            int delta = newType == UserType.Employee ? 1 : -1;
            numberOfEmployees += delta;
        }

        email = newEmail;
        type = newType;

        return numberOfEmployees;
    }
}

enum UserType {
    Customer(1),
    Employee(2);

    private final int value;

    UserType(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }
}

class Database {
    public Object[] getUserById(int userId) {
        // Implement database retrieval logic
        return new Object[]{};
    }

    public Object[] getCompany() {
        // Implement database retrieval logic
        return new Object[]{};
    }

    public void saveCompany(int newNumber) {
        // Implement database save logic
    }

    public void saveUser(User user) {
        // Implement database save logic
    }
}

class MessageBus {
    public void sendEmailChangedMessage(int userId, String newEmail) {
        // Implement message sending logic
    }
}

public class UserFactory {
    public static User create(Object[] data) {
        if (data.length < 3) {
            throw new IllegalArgumentException("Data array must have at least 3 elements");
        }

        int id = (int) data[0];
        String email = (String) data[1];
        UserType type = (UserType) data[2];

        return new User(id, email, type);
    }
}

public class Company {
    private final String domainName;
    private int numberOfEmployees;

    public Company(String domainName, int numberOfEmployees) {
        this.domainName = domainName;
        this.numberOfEmployees = numberOfEmployees;
    }

    public String getDomainName() {
        return domainName;
    }

    public int getNumberOfEmployees() {
        return numberOfEmployees;
    }

    // 従業員数を変更する
    public void changeNumberOfEmployees(int delta) {
        if (numberOfEmployees + delta < 0) {
            throw new IllegalArgumentException("Number of employees cannot be negative");
        }
        numberOfEmployees += delta;
    }

    // 会社に属するメールアドレスか
    public boolean isEmailCorporate(String email) {
        String emailDomain = email.split("@")[1];
        return emailDomain.equals(domainName);
    }
}

class CompanyFactory {
    public static Company create(Object[] data) {
        if (data.length < 2) {
            throw new IllegalArgumentException("Data array must have at least 2 elements");
        }

        String domainName = (String) data[0];
        int numberOfEmployees = (int) data[1];

        return new Company(domainName, numberOfEmployees);
    }
}

public class UserController {
    private final Database database = new Database();
    private final MessageBus messageBus = new MessageBus();

    public void changeEmail(int userId, String newEmail) {
        Object[] userData = database.getUserById(userId);
        User user = UserFactory.create(userData);

        Object[] companyData = database.getCompany();
        Company company = CompanyFactory.create(companyData);

        user.changeEmail(newEmail, company);

        database.saveCompany(company);
        database.saveUser(user);
        messageBus.sendEmailChangedMessage(userId, newEmail);
    }
}

class User {
    private int userId;
    private String email;
    private UserType type;

    public User(int userId, String email, UserType type) {
        this.userId = userId;
        this.email = email;
        this.type = type;
    }

    public void changeEmail(String newEmail, Company company) {
        if (email.equals(newEmail)) {
            return;
        }

        UserType newType = company.isEmailCorporate(newEmail)
                ? UserType.Employee
                : UserType.Customer;

        if (type != newType) {
            int delta = newType == UserType.Employee ? 1 : -1;
            company.changeNumberOfEmployees(delta);
        }

        email = newEmail;
        type = newType;
    }
}

public class Company {
    private final String domainName;
    private int numberOfEmployees;

    // 従業員数を変更する
    public void changeNumberOfEmployees(int delta) {
        if (numberOfEmployees + delta < 0) {
            throw new IllegalArgumentException("Number of employees cannot be negative");
        }
        numberOfEmployees += delta;
    }

public class UserFactory {
    public static User create(Object[] data) {
        if (data.length < 3) {
            throw new IllegalArgumentException("Data array must have at least 3 elements");
        }
        …
    }
}

◉ ドメインモデルの境界を明確にする
◉ アプリケーションを構成する層を減らす
◉ 循環依存を取り除く

import java.time.LocalDateTime;
import java.util.Optional;

public class Inquiry {
    private boolean isApproved;
    private LocalDateTime timeApproved;

    public boolean isApproved() {
        return isApproved;
    }

    public Optional<LocalDateTime> getTimeApproved() {
        return Optional.ofNullable(timeApproved);
    }
    // O/Rマッパーがデータベースからデータ取得し、そのデータを使ってこのクラスのインスタンスを生成するときに呼び出されることが意図されており、呼び出しをO/Rマッパーだけに制限したかったためプライベートにしている
    private Inquiry(boolean isApproved, LocalDateTime timeApproved) {
        if (isApproved && timeApproved == null) {
            throw new IllegalArgumentException();
        }

        this.isApproved = isApproved;
        this.timeApproved = timeApproved;
    }

    public void approve(LocalDateTime now) {
        if (isApproved) {
            return;
        }

        isApproved = true;
        timeApproved = now;
    }
}