import { app, db, schema } from '@/app.ts';
import { AppDomain, AppDomainHelper } from '../module/app-domain-drizzle.ts';
import { eq } from 'drizzle-orm';
import z from 'zod';

app
  .route({
    path: 'app_domain_manager',
    key: 'list',
    description: '获取域名列表，支持分页',
    middleware: ['auth-admin'],
    metadata: {
      args: {
        data: z.object({
          page: z.number().optional(),
          pageSize: z.number().optional(),
        }).optional()
      }
    }
  })
  .define(async (ctx) => {
    const { page = 1, pageSize = 999 } = ctx.query.data || {};
    const offset = (page - 1) * pageSize;
    const rows = await db.select().from(schema.kvAppDomain)
      .limit(pageSize)
      .offset(offset);
    const countResult = await db.select().from(schema.kvAppDomain);
    const count = countResult.length;
    ctx.body = { count, list: rows, pagination: { page, pageSize } };
    return ctx;
  })
  .addTo(app);

app
  .route({
    path: 'app_domain_manager',
    key: 'update',
    description: '更新一个域名的信息',
    middleware: ['auth-admin'],
    metadata: {
      args: {
        data: z.object({
          id: z.string().optional(),
          domain: z.string(),
          appId: z.string().optional(),
          status: z.enum(['active', 'inactive']).optional(),
          data: z.record(z.string(), z.any()).optional(),
        })
      }
    }
  })
  .define(async (ctx) => {
    const { domain, data, id, ...rest } = ctx.query.data || {};
    if (!domain) {
      ctx.throw(400, 'domain is required');
    }
    let domainInfo: AppDomain | undefined;
    if (id) {
      const domains = await db.select().from(schema.kvAppDomain).where(eq(schema.kvAppDomain.id, id)).limit(1);
      domainInfo = domains[0];
    }
    const checkAppId = async () => {
      const isUUID = (id: string) => {
        return /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(id);
      };
      if (rest.appId) {
        if (!isUUID(rest.appId)) {
          ctx.throw(400, 'appId is not valid');
        }
        const apps = await db.select().from(schema.kvApp).where(eq(schema.kvApp.id, rest.appId)).limit(1);
        const appInfo = apps[0];
        if (!appInfo) {
          ctx.throw(400, 'appId is not exist');
        }
      }
    };
    try {
      if (!domainInfo) {
        await checkAppId();
        const newDomains = await db.insert(schema.kvAppDomain).values({ domain, data: {}, ...rest }).returning();
        domainInfo = newDomains[0];
      } else {
        if (rest.status && domainInfo.status !== rest.status) {
          await AppDomainHelper.clearCache(domainInfo.domain!);
        }
        await checkAppId();
        const domainData = domainInfo.data as any;
        const updateResult = await db.update(schema.kvAppDomain)
          .set({
            domain,
            data: {
              ...domainData,
              ...data,
            },
            ...rest,
            updatedAt: new Date().toISOString()
          })
          .where(eq(schema.kvAppDomain.id, domainInfo.id))
          .returning();
        domainInfo = updateResult[0];
      }
      ctx.body = domainInfo;
    } catch (error: any) {
      if (error.code) {
        ctx.throw(error.code, error.message);
      }
      console.error(error);
      ctx.throw(500, 'update domain failed, please check the data');
    }

    return ctx;
  })
  .addTo(app);

app
  .route({
    path: 'app_domain_manager',
    key: 'delete',
    description: '删除一个域名',
    middleware: ['auth-admin'],
    metadata: {
      args: {
        data: z.object({
          id: z.string().optional(),
          domain: z.string().optional(),
        })
      }
    }
  })
  .define(async (ctx) => {
    const { id, domain } = ctx.query.data || {};
    if (!id && !domain) {
      ctx.throw(400, 'id or domain is required');
    }
    if (id) {
      await db.delete(schema.kvAppDomain).where(eq(schema.kvAppDomain.id, id));
    } else {
      await db.delete(schema.kvAppDomain).where(eq(schema.kvAppDomain.domain, domain));
    }

    ctx.body = { message: 'delete domain success' };
    return ctx;
  })
  .addTo(app);

app
  .route({
    path: 'app_domain_manager',
    key: 'get',
    description: '获取域名信息，可以通过id或者domain进行查询',
    middleware: ['auth-admin'],
    metadata: {
      args: {
        data: z.object({
          id: z.string().optional(),
          domain: z.string().optional(),
        })
      }
    }
  })
  .define(async (ctx) => {
    const { id, domain } = ctx.query.data || {};
    if (!id && !domain) {
      ctx.throw(400, 'id or domain is required');
    }
    const domains = await db.select().from(schema.kvAppDomain).where(eq(schema.kvAppDomain.id, id)).limit(1);
    const domainInfo = domains[0];
    if (!domainInfo) {
      ctx.throw(404, 'domain not found');
    }
    ctx.body = domainInfo;
    return ctx;
  })
  .addTo(app);