from dataclasses import dataclass
from typing import Optional
from datetime import date


@dataclass
class PersonId:
    """人物を一意に識別するID（値オブジェクト）"""
    value: str
    
    def __post_init__(self):
        if not self.value:
            raise ValueError("PersonIdは空にできません")


class Person:
    """人物エンティティ"""
    
    def __init__(
        self,
        person_id: PersonId,
        family_name: str,
        given_name: str,
        birth_date: date
    ):
        self._person_id = person_id
        self._family_name = family_name
        self._given_name = given_name
        self._birth_date = birth_date
        self._age = self._calculate_age()
    
    @property
    def person_id(self) -> PersonId:
        """識別子は変更不可"""
        return self._person_id
    
    @property
    def full_name(self) -> str:
        return f"{self._family_name} {self._given_name}"
    
    def change_family_name(self, new_family_name: str):
        """結婚などで姓が変わる場合"""
        self._family_name = new_family_name
    
    def _calculate_age(self) -> int:
        today = date.today()
        return today.year - self._birth_date.year
    
    def __eq__(self, other) -> bool:
        """同一性の判定はIDで行う"""
        if not isinstance(other, Person):
            return False
        return self._person_id.value == other._person_id.value
    
    def __hash__(self):
        return hash(self._person_id.value)


# 使用例
sazae = Person(
    person_id=PersonId("P001"),
    family_name="フグ田",
    given_name="サザエ",
    birth_date=date(1922, 11, 22)
)

katsuo = Person(
    person_id=PersonId("P002"),
    family_name="磯野",
    given_name="カツオ",
    birth_date=date(2014, 1, 1)
)

@dataclass(frozen=True)
class Address:
    """住所の値オブジェクト（不変）"""
    prefecture: str
    city: str
    town: str
    
    def __post_init__(self):
        if not all([self.prefecture, self.city, self.town]):
            raise ValueError("住所の全ての項目を入力してください")
    
    def full_address(self) -> str:
        return f"{self.prefecture}{self.city}{self.town}"
    
    def __eq__(self, other) -> bool:
        """値の等価性で判定"""
        if not isinstance(other, Address):
            return False
        return (
            self.prefecture == other.prefecture and
            self.city == other.city and
            self.town == other.town
        )


@dataclass(frozen=True)
class Money:
    """金額の値オブジェクト"""
    amount: int
    currency: str = "JPY"
    
    def __post_init__(self):
        if self.amount < 0:
            raise ValueError("金額は0以上である必要があります")
    
    def add(self, other: 'Money') -> 'Money':
        """加算（新しいインスタンスを返す）"""
        if self.currency != other.currency:
            raise ValueError("通貨が異なります")
        return Money(self.amount + other.amount, self.currency)
    
    def __str__(self):
        return f"¥{self.amount:,}"


# 使用例
isono_house = Address(
    prefecture="東京都",
    city="世田谷区",
    town="あさひが丘3丁目"
)

pocket_money = Money(500)
additional = Money(300)
total = pocket_money.add(additional)  # 新しいインスタンスが返る
print(total)  # ¥800

from typing import List


class Family:
    """家族集約（波平さんが集約ルート）"""
    
    def __init__(
        self,
        household_head: Person,  # 世帯主（集約ルート）
        family_name: str,
        address: Address
    ):
        self._household_head = household_head
        self._family_name = family_name
        self._address = address
        self._members: List[Person] = [household_head]
    
    @property
    def household_head(self) -> Person:
        return self._household_head
    
    @property
    def family_name(self) -> str:
        return self._family_name
    
    @property
    def address(self) -> Address:
        return self._address
    
    @property
    def members(self) -> List[Person]:
        """メンバーのコピーを返す（直接変更させない）"""
        return self._members.copy()
    
    def add_member(self, person: Person):
        """家族メンバーの追加（集約ルート経由）"""
        if person in self._members:
            raise ValueError("既に家族メンバーです")
        
        # ビジネスルール：同じ姓であること
        if person.full_name.split()[0] != self._family_name:
            raise ValueError(f"姓が{self._family_name}ではありません")
        
        self._members.append(person)
    
    def remove_member(self, person: Person):
        """家族メンバーの削除"""
        if person == self._household_head:
            raise ValueError("世帯主は削除できません")
        
        if person not in self._members:
            raise ValueError("家族メンバーではありません")
        
        self._members.remove(person)
    
    def move_to(self, new_address: Address):
        """引っ越し（家族全員の住所が変わる）"""
        self._address = new_address
    
    def member_count(self) -> int:
        return len(self._members)


# 使用例
namihei = Person(
    person_id=PersonId("P003"),
    family_name="磯野",
    given_name="波平",
    birth_date=date(1895, 1, 1)
)

isono_family = Family(
    household_head=namihei,
    family_name="磯野",
    address=isono_house
)

# カツオくんを追加
isono_family.add_member(katsuo)

print(f"{isono_family.family_name}家は{isono_family.member_count()}人家族です")
# 磯野家は2人家族です

from abc import ABC, abstractmethod
from typing import Optional


class FamilyRepository(ABC):
    """家族リポジトリのインターフェース"""
    
    @abstractmethod
    def save(self, family: Family) -> None:
        """家族情報を保存"""
        pass
    
    @abstractmethod
    def find_by_family_name(self, family_name: str) -> Optional[Family]:
        """姓から家族を検索"""
        pass


class InMemoryFamilyRepository(FamilyRepository):
    """メモリ上に保存する実装（テスト用）"""
    
    def __init__(self):
        self._families: dict[str, Family] = {}
    
    def save(self, family: Family) -> None:
        self._families[family.family_name] = family
        print(f"{family.family_name}家を保存しました")
    
    def find_by_family_name(self, family_name: str) -> Optional[Family]:
        return self._families.get(family_name)


# 使用例
repository = InMemoryFamilyRepository()

# 磯野家を保存
repository.save(isono_family)

# 検索
found_family = repository.find_by_family_name("磯野")
if found_family:
    print(f"見つかりました：{found_family.family_name}家（{found_family.member_count()}人）")

class FamilyRelationService:
    """家族関係を扱うドメインサービス"""
    
    @staticmethod
    def are_related(family1: Family, family2: Family) -> bool:
        """2つの家族が親戚関係にあるかチェック"""
        # 簡易実装：共通のメンバーがいれば親戚とする
        members1 = set(family1.members)
        members2 = set(family2.members)
        return len(members1 & members2) > 0
    
    @staticmethod
    def merge_families(
        family1: Family,
        family2: Family,
        new_family_name: str
    ) -> Family:
        """結婚などで2つの家族を統合"""
        # 新しい家族を作成（簡易実装）
        new_family = Family(
            household_head=family1.household_head,
            family_name=new_family_name,
            address=family1.address
        )
        
        # メンバーを追加（重複チェックは省略）
        for member in family2.members:
            if member != family2.household_head:
                try:
                    new_family.add_member(member)
                except ValueError:
                    pass  # 姓が異なる場合などはスキップ
        
        return new_family


# 使用例
relation_service = FamilyRelationService()

# フグ田家も作成（サザエさんの婚家）
masuo = Person(
    person_id=PersonId("P004"),
    family_name="フグ田",
    given_name="マスオ",
    birth_date=date(1917, 1, 1)
)

fuguta_house = Address(
    prefecture="東京都",
    city="世田谷区",
    town="あさひが丘3丁目"
)

fuguta_family = Family(
    household_head=masuo,
    family_name="フグ田",
    address=fuguta_house
)

fuguta_family.add_member(sazae)

# 親戚判定（サザエさんが両方にいるので親戚）
if relation_service.are_related(isono_family, fuguta_family):
    print("磯野家とフグ田家は親戚関係です")