Controller
   ↓
Service
   ↓
Repository
   ↓
Model

// ❌ BAD: Repository InterfaceとEloquent直接アクセスが混在
class LoginUseCase
{
    public function __construct(
        private MemberRepositoryInterface $memberRepository,  // ← Repository使用
        private LoginHistoryRepositoryInterface $loginHistoryRepository
    ) {}

    public function execute(string $tel, string $password)
    {
        // Repository経由
        $member = $this->memberRepository->findByTel($tel);

        // ❌ しかし同じクラス内でEloquent直接アクセス
        $program = Program::find($programId);  // ← Eloquent直接

        // これが「なんちゃってRepository」
    }
}

// 開発者Aの判断: これは「シンプル」だから直接アクセス
Member::where('city_id', $cityId)->where('status', 1)->get();

// 開発者Bの判断: 2つの条件は「複雑」だからRepository経由
$this->memberRepository->findByCityAndStatus($cityId, 1);

// 開発者Cの判断: テストで必要だからRepository作成
$this->memberRepository->find($id);

// → 統一性がない = メンテナンス不可能

Repository Pattern を今回のプロジェクトでは採用しない = Eloquent を全面的に使う

// ✅ シンプルな操作
$member = Member::find($id);
$member->name = 'Updated Name';
$member->save();

// ✅ Eloquent Relationshipの活用
$member = Member::with('points', 'program')->find($id);

// ✅ Eloquent Scopeの活用
$activeMembers = Member::active()->get();

app/
├── Http/
│   ├── Controllers/
│   │   └── V1/
│   │       └── Api/
│   │           ├── LoginController.php
│   │           └── Member/
│   │               └── PointController.php
│   │
│   ├── Requests/
│   │   └── V1/
│   │       └── Api/
│   │           └── LoginRequest.php
│   │
│   └── Middleware/
│       └── AuthenticateToken.php
│
├── UseCases/
│   ├── LoginUseCase.php
│   └── PointListUseCase.php
│
├── Services/
│   ├── Auth/
│   │   ├── TokenService.php
│   │   └── PasswordHashService.php
│   │
│   ├── Payment/
│   │   └── PaymentCalculationService.php
│   │
│   └── External/
│       ├── Contracts/              # インターフェース（重要）
│       │   ├── PaymentGatewayInterface.php
│       │   └── SmsServiceInterface.php
│       │
│       └── Implementations/        # 外部API連携実装
│           └── SBPayment/
│               └── SBPaymentGatewayService.php
│
├── Models/
│   ├── MemberDB/                   # スキーマ1（会員管理DB）
│   │   ├── Member.php
│   │   └── ProvisionalMember.php
│   │
│   └── ServiceDB/                  # スキーマ2（サービス管理DB）
│       ├── LoginHistory.php
│       └── Program.php
│
├── DTOs/                           # Data Transfer Objects
│   ├── LoginRequest.php
│   ├── LoginResponse.php
│   └── LoginToken.php
│
├── ValueObjects/                   # Value Objects
│   ├── Tel.php
│   ├── Password.php
│   └── MemberCode.php
│
├── Exceptions/                     # カスタム例外
│   ├── Auth/
│   │   ├── InvalidPasswordException.php
│   │   └── AccountLockedException.php
│   └── Member/
│       └── MemberNotFoundException.php
│
└── Util/                           # ユーティリティクラス
    └── IpAddress.php

HTTP Request
    ↓
Controller (HTTPハンドリング)
    ↓
UseCase (ビジネスフローのオーケストレーション)
    ↓
    ├─→ Service (ビジネスロジック)
    │       ↓
    │       └─→ External API (Interfaceを経由)
    │
    └─→ Model (Eloquent - Active Record)
            ↓
            Database

namespace App\Http\Controllers;

use App\DTOs\LoginRequest as LoginRequestDTO;
use App\Http\Requests\LoginRequest;
use App\UseCases\LoginUseCase;
use Illuminate\Http\JsonResponse;

class LoginController extends Controller
{
    public function __construct(
        private LoginUseCase $loginUseCase
    ) {}

    public function index(LoginRequest $request): JsonResponse
    {
        // バリデーション済みデータを取得
        $validated = $request->validated();

        // リクエストDTOを作成
        $requestDTO = new LoginRequestDTO(
            tel: $validated['tel'],
            password: $validated['password'],
            ip: $request->ip(),
            userAgent: $request->userAgent()
        );

        // ユースケース実行
        $response = $this->loginUseCase->execute($requestDTO);

        return response()->json($response->toArray(), 200);
    }
}

namespace App\UseCases;

use App\DTOs\LoginRequest;
use App\DTOs\LoginResponse;
use App\Models\MemberDB\Member;
use App\Models\ServiceDB\LoginHistory;
use App\Services\Auth\TokenService;
use App\ValueObjects\Password;
use App\ValueObjects\Tel;
use Illuminate\Support\Facades\DB;

class LoginUseCase
{
    public function __construct(
        private TokenService $tokenService
    ) {}

    public function execute(LoginRequest $request): LoginResponse
    {
        $tel = new Tel($request->tel);
        $inputPassword = Password::fromPlainText($request->password);

        // ✅ Eloquent直接使用（データベースアクセス）
        $member = Member::on('memberdb_r')
            ->where('tel', $tel->value())
            ->where('member_type', 1)
            ->first();

        if ($member === null) {
            throw new MemberNotFoundException;
        }

        // ビジネスルールはModel内に
        $member->ensureCanLogin();

        // パスワード検証（ValueObjectで実装）
        if (!$member->authenticate($inputPassword)) {
            $this->recordAuthenticationFailure($member);
            throw new InvalidPasswordException;
        }

        // トランザクション開始
        DB::connection('memberdb_w')->beginTransaction();

        try {
            // 認証成功を記録
            $this->recordAuthenticationSuccess($member);

            // ログイン履歴もEloquent直接
            LoginHistory::create([
                'member_id' => $member->id,
                'login_at' => now(),
            ]);

            DB::connection('memberdb_w')->commit();
        } catch (Exception $e) {
            DB::connection('memberdb_w')->rollBack();
            throw $e;
        }

        // トークン生成（Serviceに委譲）
        $token = $this->tokenService->generateLoginToken($member);

        return new LoginResponse(
            loginToken: $token->token(),
            memberId: $token->memberId(),
            expiredAt: $token->expiredAt()->format('Y/m/d H:i:s')
        );
    }

    private function recordAuthenticationSuccess(Member $member): void
    {
        $member->recordAuthenticationSuccess();
        $member->setConnection('memberdb_w');
        $member->save();
    }

    private function recordAuthenticationFailure(Member $member): void
    {
        $member->recordAuthenticationFailure();
        $member->setConnection('memberdb_w');
        $member->save();
    }
}

namespace App\Services\Auth;

use App\DTOs\LoginToken;
use App\Models\MemberDB\Member;
use App\ValueObjects\MemberCode;
use Carbon\Carbon;

class TokenService
{
    public function __construct(
        private readonly string $cryptMethod,
        private readonly string $cryptKey,
        private readonly int $tokenTtl
    ) {}

    /**
     * ログイントークンを生成
     */
    public function generateLoginToken(Member $member): LoginToken
    {
        $memberId = $member->id;
        $memberCode = $member->member_code;

        $now = Carbon::now();
        $expiredAt = $now->timestamp + $this->tokenTtl;

        $content = [
            'login_at' => $now->format('Y-m-d H:i:s'),
            'user_id' => $memberId,
            'expired_at' => $expiredAt,
        ];

        // 暗号化処理
        $iv = $this->generateIv();
        $encrypt = $this->encrypt($content, $iv);
        $token = $this->encodeToken($iv, $encrypt);

        return new LoginToken(
            token: $token,
            memberId: $memberId,
            memberCode: $memberCode,
            expiredAt: DateTimeImmutable::createFromMutable(
                Carbon::createFromTimestamp($expiredAt)
            )
        );
    }

    // 暗号化処理の詳細は省略...
}

namespace App\Models\MemberDB;

use Illuminate\Database\Eloquent\Model;

class Member extends Model
{
    // ビジネスルール定数
    public const LIMIT_AUTH_FAILED_COUNT = 5;
    public const STOP_FLAG_ACTIVE = 0;
    public const STOP_FLAG_STOPPING = 1;

    protected $table = 'members';
    protected $connection = 'memberdb_r';

    protected $fillable = [
        'tel', 'password', 'member_type', 'stop_flag',
        'auth_failed_count', 'account_unlock_date'
    ];

    // ============================================================
    // ビジネスロジック（Active Recordパターンの重要な部分）
    // ============================================================

    /**
     * アカウントが有効かチェック
     */
    public function isActive(): bool
    {
        return $this->stop_flag === self::STOP_FLAG_ACTIVE;
    }

    /**
     * アカウントが停止中かチェック
     */
    public function isStopped(): bool
    {
        return $this->stop_flag === self::STOP_FLAG_STOPPING;
    }

    /**
     * アカウントがロックされているかチェック
     */
    public function isLocked(): bool
    {
        if ($this->auth_failed_count < self::LIMIT_AUTH_FAILED_COUNT) {
            return false;
        }

        if ($this->account_unlock_date === null) {
            return false;
        }

        return $this->account_unlock_date > now();
    }

    /**
     * ログイン可能かチェック（ビジネスルール）
     */
    public function ensureCanLogin(): void
    {
        if ($this->isStopped()) {
            throw new AccountStoppedException;
        }

        if ($this->isLocked()) {
            throw new AccountLockedException(
                $this->account_unlock_date
            );
        }
    }

    /**
     * パスワード認証
     */
    public function authenticate(Password $inputPassword): bool
    {
        return $inputPassword->verify($this->password);
    }

    /**
     * 認証失敗時の処理（状態変更）
     */
    public function recordAuthenticationFailure(): void
    {
        // 既にロック中だがロック期限が過ぎている場合はリセット
        if ($this->auth_failed_count >= self::LIMIT_AUTH_FAILED_COUNT
            && $this->account_unlock_date !== null
            && $this->account_unlock_date <= now()) {
            $this->auth_failed_count = 1;
            $this->account_unlock_date = null;
        } else {
            $this->auth_failed_count++;

            // リミットに達したらアカウントロック
            if ($this->auth_failed_count >= self::LIMIT_AUTH_FAILED_COUNT) {
                $this->account_unlock_date = now()->addMinutes(30);
            }
        }
    }

    /**
     * 認証成功時の処理（状態変更）
     */
    public function recordAuthenticationSuccess(): void
    {
        $this->auth_failed_count = 0;
        $this->account_unlock_date = null;
    }
}

namespace App\DTOs;

final readonly class LoginToken
{
    public function __construct(
        private string $token,
        private int $memberId,
        private string $memberCode,
        private DateTimeImmutable $expiredAt
    ) {}

    // APIレスポンス用のシリアライゼーション
    public function toArray(): array
    {
        return [
            'login_token' => $this->token,
            'member_id' => $this->memberId,
            'member_code' => $this->memberCode,
            'expired_at' => $this->expiredAt->format('Y-m-d H:i:s'),
        ];
    }

    // Getter
    public function token(): string
    {
        return $this->token;
    }

    public function memberId(): int
    {
        return $this->memberId;
    }

    public function expiredAt(): DateTimeImmutable
    {
        return $this->expiredAt;
    }
}

namespace App\ValueObjects;

final class Tel
{
    private string $value;

    public function __construct(string $tel)
    {
        // ノーマライゼーション
        $normalized = str_replace(['-', ' ', '　'], '', $tel);

        // バリデーション
        if (!preg_match('/^0[0-9]{9,10}$/', $normalized)) {
            throw new InvalidArgumentException('Invalid phone number format');
        }

        $this->value = $normalized;
    }

    public function value(): string
    {
        return $this->value;
    }

    public function equals(Tel $other): bool
    {
        return $this->value === $other->value;
    }
}

namespace App\ValueObjects;

use Illuminate\Support\Facades\Hash;

final class Password
{
    private string $plain;

    private function __construct(string $plain)
    {
        $this->plain = $plain;
    }

    public static function fromPlainText(string $plainPassword): self
    {
        if (strlen($plainPassword) < 8) {
            throw new InvalidArgumentException('Password too short');
        }

        return new self($plainPassword);
    }

    public function verify(string $storedHash): bool
    {
        return Hash::check($this->plain, $storedHash);
    }
}

データアクセスが必要
    ↓
Q: DBアクセス？ 外部API？
    ↓
    ├─ DB → Eloquent直接使用
    └─ 外部API → Interface使用

// ✅ Eloquent直接使用
$member = Member::find($id);

// ✅ Eloquent直接使用（何個条件があっても）
$members = Member::where('city_id', $cityId)
    ->where('status', 1)
    ->where('deleted_at', null)
    ->get();

// ✅ Eloquent直接使用（Relationshipを活用）
$member = Member::with([
    'points' => function ($query) {
        $query->where('program_id', $programId);
    },
    'program',
    'rank'
])->find($memberId);

// Member Model内:
public function scopeWithPointsAndProgram($query, int $programId)
{
    return $query->with([
        'points' => fn($q) => $q->where('program_id', $programId),
        'program',
        'rank'
    ]);
}

// 使用時:
$member = Member::withPointsAndProgram($programId)->find($memberId);

// ✅ Interface使用（DBではないため）
namespace App\Services\External\Contracts;

interface PaymentGatewayInterface
{
    public function processPayment(array $params): array;
    public function refundPayment(string $transactionId): array;
}

// 実装
namespace App\Services\External\Implementations\SBPayment;

class SBPaymentGatewayService implements PaymentGatewayInterface
{
    public function processPayment(array $params): array
    {
        // 外部API呼び出し実装...
    }

    public function refundPayment(string $transactionId): array
    {
        // 外部API呼び出し実装...
    }
}

// Relationship
$member->points;  // Eager Loading可能

// Scope
Member::active()->get();

// Accessor
$member->full_name;  // getFullNameAttribute()

// Mutator
$member->password = 'plaintext';  // setPasswordAttribute()

namespace Tests\Feature;

use App\Models\MemberDB\Member;
use Illuminate\Foundation\Testing\DatabaseTransactions;
use Illuminate\Support\Facades\Hash;
use Tests\TestCase;

class LoginUseCaseTest extends TestCase
{
    use DatabaseTransactions;

    public function test_login_success(): void
    {
        // テストデータ作成（Factory使用）
        $member = Member::factory()->create([
            'tel' => '09000000000',
            'password' => Hash::make('password'),
            'member_type' => 1,
            'stop_flag' => 0,
            'auth_failed_count' => 0,
        ]);

        // APIリクエスト実行
        $response = $this->postJson('/v1/api/login', [
            'tel' => '09000000000',
            'password' => 'password',
        ]);

        // アサーション
        $response->assertStatus(200);
        $response->assertJsonStructure([
            'login_token',
            'member_id',
            'member_code',
            'expired_at',
        ]);

        // データベース検証
        $this->assertDatabaseHas('login_history', [
            'member_id' => $member->id,
        ]);
    }

    public function test_login_failure_with_invalid_password(): void
    {
        $member = Member::factory()->create([
            'tel' => '09000000000',
            'password' => Hash::make('correct_password'),
        ]);

        $response = $this->postJson('/v1/api/login', [
            'tel' => '09000000000',
            'password' => 'wrong_password',
        ]);

        $response->assertStatus(404);

        // 認証失敗カウントが増加していることを確認
        $member->refresh();
        $this->assertEquals(1, $member->auth_failed_count);
    }
}