Api.php

<?php

declare(strict_types=1);

namespace TypechoPlugin\ZaoApi;

use Widget\Base;
use TypechoPlugin\ZaoApi\Route;
use TypechoPlugin\ZaoApi\Util\Http;

// Posts
use TypechoPlugin\ZaoApi\Api\Contents\Posts\Query as PostsQuery;
use TypechoPlugin\ZaoApi\Api\Contents\Posts\Mutation as PostsMutation;

// Pages
use TypechoPlugin\ZaoApi\Api\Contents\Pages\Query as PagesQuery;
use TypechoPlugin\ZaoApi\Api\Contents\Pages\Mutation as PagesMutation;

// Meta - Categories
use TypechoPlugin\ZaoApi\Api\Meta\Categories\Mutation as CategoriesMutation;
use TypechoPlugin\ZaoApi\Api\Meta\Categories\Query as CategoriesQuery;

// Meta - Tags
use TypechoPlugin\ZaoApi\Api\Meta\Tags\Query as TagQuery;
use TypechoPlugin\ZaoApi\Api\Meta\Tags\Mutation as TagMutation;

// Users
use TypechoPlugin\ZaoApi\Api\User\Query as UserQuery;
use TypechoPlugin\ZaoApi\Api\User\Mutation as UserMutation;

use TypechoPlugin\ZaoApi\Api\Action\Login   as UserLogin;
use TypechoPlugin\ZaoApi\Api\Action\Logout as UserLogout;
use TypechoPlugin\ZaoApi\Api\Action\Register as UserRegister;

// Comments
use TypechoPlugin\ZaoApi\Api\Comments\Query as CmtQuery;
use TypechoPlugin\ZaoApi\Api\Comments\Mutation  as CmtMutation;



if (!defined('__TYPECHO_ROOT_DIR__')) {
  exit;
}

class Api extends Base implements \Widget\ActionInterface
{
  /** 统一解析 HTTP 方法（考虑 _method/Override 与 HEAD→GET） */
  private function resolveMethod(): string
  {
    $r = $this->request;
    $method = strtoupper((string)($r->getServer('REQUEST_METHOD') ?? 'GET'));
    $override = $r->get('_method') ?: $r->getServer('HTTP_X_HTTP_METHOD_OVERRIDE');
    if ($override) $method = strtoupper((string)$override);
    if ($method === 'HEAD') $method = 'GET';
    return $method;
  }

  // ========= Posts =========
  #[Route(name: 'posts_index', path: '/posts')]
  public function postsIndex()
  {
    $m = $this->resolveMethod();
    if ($m === 'OPTIONS') {
      header('Allow: GET, POST, OPTIONS');
      http_response_code(204);
      return;
    }
    switch ($m) {
      case 'GET':
        (new PostsQuery())->list($this->request);
        return;
      case 'POST':
        (new PostsMutation())->create($this->request);
        return;
      default:
        header('Allow: GET, POST, OPTIONS');
        Http::err('method_not_allowed', '只允许 GET, POST', 405);
    }
  }

  #[Route(name: 'posts_show', path: '/posts/[cid]')]
  public function postsShow()
  {
    $m = $this->resolveMethod();
    if ($m === 'OPTIONS') {
      header('Allow: GET, PUT, PATCH, DELETE, OPTIONS');
      http_response_code(204);
      return;
    }
    switch ($m) {
      case 'GET':
        (new PostsQuery())->show($this->request);
        return;
      case 'PUT':
      case 'PATCH':
        (new PostsMutation())->update($this->request);
        return;
      case 'DELETE':
        (new PostsMutation())->delete($this->request);
        return;
      default:
        header('Allow: GET, PUT, PATCH, DELETE, OPTIONS');
        Http::err('method_not_allowed', '只允许 GET, PUT, PATCH, DELETE', 405);
    }
  }

  // ========= Pages =========
  #[Route(name: 'pages_collection', path: '/pages')]
  public function pagesCollection()
  {
    $m = $this->resolveMethod();
    if ($m === 'OPTIONS') {
      header('Allow: GET, POST, OPTIONS');
      http_response_code(204);
      return;
    }
    switch ($m) {
      case 'GET':
        (new PagesQuery())->show($this->request);
        return;
      case 'POST':
        (new PagesMutation())->create($this->request);
        return;
      default:
        header('Allow: GET, POST, OPTIONS');
        Http::err('method_not_allowed', '只允许 GET, POST', 405);
    }
  }

  #[Route(name: 'pages_resource', path: '/pages/[cid]')]
  public function pagesResource()
  {
    $m = $this->resolveMethod();
    if ($m === 'OPTIONS') {
      header('Allow: GET, PUT, PATCH, DELETE, OPTIONS');
      http_response_code(204);
      return;
    }
    switch ($m) {
      case 'GET':
        (new PagesQuery())->show($this->request);
        return;
      case 'PUT':
      case 'PATCH':
        (new PagesMutation())->update($this->request);
        return;
      case 'DELETE':
        (new PagesMutation())->delete($this->request);
        return;
      default:
        header('Allow: GET, PUT, PATCH, DELETE, OPTIONS');
        Http::err('method_not_allowed', '只允许 GET, PUT, PATCH, DELETE', 405);
    }
  }

  // ========= Categories =========
  #[Route(name: 'categories_collection', path: '/categories')]
  public function categoriesCollection()
  {
    $m = $this->resolveMethod();
    if ($m === 'OPTIONS') {
      header('Allow: GET, POST, OPTIONS');
      http_response_code(204);
      return;
    }
    switch ($m) {
      case 'GET':
        (new CategoriesQuery())->list($this->request);
        return;
      case 'POST':
        (new CategoriesMutation())->create($this->request);
        return;
        // 补充DELETE方法处理（关键！）
      case 'DELETE':
        (new CategoriesMutation())->delete($this->request);
        return;
      default:
        header('Allow: GET, POST, OPTIONS');
        Http::err('method_not_allowed', '只允许 GET, POST, DELETE', 405);
    }
  }

  #[Route(name: 'categories_resource', path: '/categories/[mid]')]
  public function categoriesResource()
  {
    $m = $this->resolveMethod();
    if ($m === 'OPTIONS') {
      header('Allow: GET, PUT, PATCH, DELETE, OPTIONS');
      http_response_code(204);
      return;
    }
    switch ($m) {
      case 'GET':
        (new CategoriesQuery())->show($this->request);
        return;
      case 'PUT':
      case 'PATCH':
        (new CategoriesMutation())->update($this->request);
        return;
      case 'DELETE':
        (new CategoriesMutation())->delete($this->request);
        return;
      default:
        header('Allow: GET, PUT, PATCH, DELETE, OPTIONS');
        Http::err('method_not_allowed', '只允许 GET, PUT, PATCH, DELETE', 405);
    }
  }

  // ========= Tags =========
  #[Route(name: 'tags_collection', path: '/tags')]
  public function tagsCollection()
  {
    $m = $this->resolveMethod();
    if ($m === 'OPTIONS') {
      header('Allow: GET, POST, OPTIONS');
      http_response_code(204);
      return;
    }
    switch ($m) {
      case 'GET':
        (new TagQuery())->list($this->request);
        return;
      case 'POST':
        (new TagMutation())->create($this->request);
        return;
        // 补充DELETE方法
      case 'DELETE':
        (new TagMutation())->delete($this->request);
        return;
      default:
        header('Allow: GET, POST, OPTIONS');
        Http::err('method_not_allowed', '只允许 GET, POST', 405);
    }
  }

  #[Route(name: 'tags_resource', path: '/tags/[mid]')]
  public function tagsResource()
  {
    $m = $this->resolveMethod();
    if ($m === 'OPTIONS') {
      header('Allow: GET, PUT, PATCH, DELETE, OPTIONS');
      http_response_code(204);
      return;
    }
    switch ($m) {
      case 'GET':
        (new TagQuery())->show($this->request);
        return;
      case 'PUT':
      case 'PATCH':
        (new TagMutation())->update($this->request);
        return;
      case 'DELETE':
        (new TagMutation())->delete($this->request);
        return;
      default:
        header('Allow: GET, PUT, PATCH, DELETE, OPTIONS');
        Http::err('method_not_allowed', '只允许 GET, PUT, PATCH, DELETE', 405);
    }
  }

  // ========= Comments =========
  #[Route(name: 'comments_collection', path: '/comments')]
  public function commentsCollection()
  {
    $m = $this->resolveMethod();
    if ($m === 'OPTIONS') {
      header('Allow: GET, POST, OPTIONS');
      http_response_code(204);
      return;
    }
    switch ($m) {
      case 'GET':
        (new CmtQuery())->list($this->request);
        return;
      case 'POST':
        (new CmtMutation())->create($this->request);
        return;
      default:
        header('Allow: GET, POST, OPTIONS');
        Http::err('method_not_allowed', '只允许 GET, POST', 405);
    }
  }

  #[Route(name: 'comments_resource', path: '/comments/[coid]')]
  public function commentsResource()
  {
    $m = $this->resolveMethod();
    if ($m === 'OPTIONS') {
      header('Allow: GET, PUT, PATCH, DELETE, OPTIONS');
      http_response_code(204);
      return;
    }
    switch ($m) {
      case 'GET':
        (new CmtQuery())->show($this->request);
        return;
      case 'PUT':
      case 'PATCH':
        (new CmtMutation())->update($this->request);
        return;
      case 'DELETE':
        (new CmtMutation())->delete($this->request);
        return;
      default:
        header('Allow: GET, PUT, PATCH, DELETE, OPTIONS');
        Http::err('method_not_allowed', '只允许 GET, PUT, PATCH, DELETE', 405);
    }
  }

  // ========= Users =========
  // 用户列表/创建 - GET /users
  #[Route(name: 'users_index', path: '/users')]
  public function usersIndex()
  {
    $m = $this->resolveMethod();
    if ($m === 'OPTIONS') {
      header('Allow: GET, POST, OPTIONS');
      http_response_code(204);
      return;
    }
    switch ($m) {
      case 'GET':
        (new UserQuery())->list($this->request);
        return;
      case 'POST':
        (new UserMutation())->create($this->request);
        return;
      default:
        header('Allow: GET, OPTIONS');
        Http::err('method_not_allowed', '只允许 GET, POST', 405);
    }
  }


  // 用户登录 - POST /users/login
  #[Route(name: 'users_login', path: '/users/login')]
  public function usersLogin()
  {
    $m = $this->resolveMethod();
    if ($m === 'OPTIONS') {
      header('Allow: POST, OPTIONS');
      http_response_code(204);
      return;
    }
    switch ($m) {
      case 'POST':
        (new UserLogin())->login($this->request);
        return;
      default:
        header('Allow: POST, OPTIONS');
        Http::err('method_not_allowed', '只允许 POST', 405);
    }
  }

  // 用户注册 - POST /users/register
  #[Route(name: 'users_register', path: '/users/register')]
  public function usersRegister()
  {
    $m = $this->resolveMethod();
    if ($m === 'OPTIONS') {
      header('Allow: POST, OPTIONS');
      http_response_code(204);
      return;
    }
    switch ($m) {
      case 'POST':
        UserRegister::alloc()->register($this->request);
        return;
      default:
        header('Allow: POST, OPTIONS');
        Http::err('method_not_allowed', '只允许 POST', 405);
    }
  }
  #[Route(name: 'users_logout', path: '/users/logout')]
  public function usersLogout()
  {
    $m = $this->resolveMethod();
    if ($m === 'OPTIONS') {
      header('Allow: POST, OPTIONS');
      http_response_code(204);
      return;
    }
    switch ($m) {
      case 'POST':
        (new UserLogout())->logout($this->request);
        return;
      default:
        header('Allow: POST, OPTIONS');
        Http::err('method_not_allowed', '只允许 POST', 405);
    }
  }



  // 用户详细 - GET /users/[uid] (更新及删除)
  #[Route(name: 'users_show', path: '/users/[uid]')]
  public function usersShow()
  {
    $m = $this->resolveMethod();
    if ($m === 'OPTIONS') {
      header('Allow: GET, PUT, PATCH, DELETE, OPTIONS');
      http_response_code(204);
      return;
    }
    switch ($m) {
      case 'GET':
        (new UserQuery())->show($this->request);  // 获取用户详细信息
        return;
      case 'PUT':
      case 'PATCH':
        (new UserMutation())->update($this->request);  // 更新用户信息
        return;
      case 'DELETE':
        (new UserMutation())->delete($this->request);  // 删除用户
        return;
      default:
        header('Allow: GET, PUT, PATCH, DELETE, OPTIONS');
        Http::err('method_not_allowed', '只允许 GET, PUT, PATCH, DELETE', 405);
    }
  }


  /**
   * 用户密码重置 - PUT/PATCH /users/[uid]/password
   * 专用路由：仅处理密码重置，与用户信息更新分离
   */
  #[Route(name: 'users_reset_password', path: '/users/[uid]/password')]
  public function usersResetPassword()
  {
    $m = $this->resolveMethod();
    // OPTIONS 预检请求处理（跨域必备）
    if ($m === 'OPTIONS') {
      header('Allow: PUT, PATCH, OPTIONS');
      http_response_code(204);
      return;
    }

    // 仅允许 PUT/PATCH 方法（修改密码属于资源更新）
    switch ($m) {
      case 'PUT':
      case 'PATCH':
        (new UserMutation())->resetPassword($this->request);
        return;
      default:
        header('Allow: PUT, PATCH, OPTIONS');
        Http::err('method_not_allowed', '只允许 PUT, PATCH', 405);
    }
  }





  public function action() {}
}