"use server";

import { z } from "zod";
import { and, desc, eq, isNull } from "drizzle-orm";
import { revalidatePath } from "next/cache";
import { auth } from "@/lib/auth";
import { db } from "@/lib/db";
import { accounts, channels, type Account } from "@/lib/db/schema";

async function requireUser() {
  const session = await auth();
  if (!session?.user?.id) {
    throw new Error("请先登录");
  }
  return session.user.id;
}

const accountSchema = z.object({
  name: z.string().min(1, "请输入账户名称").max(100),
  accountType: z.enum(["BANK", "E_WALLET", "CASH"] as const),
  balanceType: z.enum(["ASSET", "LIABILITY", "EQUITY"] as const),
  primaryCurrency: z.string().trim().max(10).optional().nullable(),
  supportedCurrencies: z.array(z.string().trim()).optional().nullable(),
  remark: z.string().max(500).optional().nullable(),
  ext: z.string().optional().nullable(),

  // 银行账户字段
  issuerName: z.string().max(100).optional().nullable(),
  accountNumber: z.string().max(100).optional().nullable(),

  // 电子钱包字段
  platform: z.string().max(64).optional().nullable(),
  accountId: z.string().max(100).optional().nullable(),

  // 现金账户字段
  location: z.string().max(150).optional().nullable(),
});

export type AccountInput = z.infer<typeof accountSchema>;

export type AccountWithChannels = Account & {
  channelCount: number;
};

export async function getAccountsAction(): Promise<{
  success: boolean;
  data?: AccountWithChannels[];
  error?: string;
}> {
  try {
    const userId = await requireUser();

    const userAccounts = await db
      .select()
      .from(accounts)
      .where(and(eq(accounts.userId, userId), isNull(accounts.deletedAt)))
      .orderBy(desc(accounts.createdAt));

    const userChannels = await db
      .select({ id: channels.id, refAccounts: channels.refAccounts })
      .from(channels)
      .where(and(eq(channels.userId, userId), isNull(channels.deletedAt)));

    const result: AccountWithChannels[] = userAccounts.map((acc) => {
      const count = userChannels.filter((ch) =>
        Array.isArray(ch.refAccounts) && ch.refAccounts.includes(acc.id)
      ).length;
      return {
        ...acc,
        channelCount: count,
      };
    });

    return { success: true, data: result };
  } catch (err) {
    console.error("getAccountsAction error:", err);
    return { success: false, error: err instanceof Error ? err.message : "获取账户失败" };
  }
}

export async function createAccountAction(
  data: AccountInput
): Promise<{ success: boolean; data?: Account; error?: string }> {
  try {
    const userId = await requireUser();
    const parsed = accountSchema.safeParse(data);
    if (!parsed.success) {
      return { success: false, error: parsed.error.issues[0]?.message || "参数错误" };
    }

    const val = parsed.data;
    const [newAccount] = await db
      .insert(accounts)
      .values({
        userId,
        name: val.name.trim(),
        accountType: val.accountType,
        balanceType: val.balanceType,
        primaryCurrency: val.primaryCurrency ? val.primaryCurrency.toUpperCase() : null,
        supportedCurrencies: val.supportedCurrencies && val.supportedCurrencies.length > 0 ? val.supportedCurrencies : null,
        remark: val.remark?.trim() || null,
        ext: val.ext?.trim() || null,
        issuerName: val.issuerName?.trim() || null,
        accountNumber: val.accountNumber?.trim() || null,
        platform: val.platform?.trim() || null,
        accountId: val.accountId?.trim() || null,
        location: val.location?.trim() || null,
        isActive: true,
      })
      .returning();

    revalidatePath("/accounts");
    revalidatePath("/channels");
    revalidatePath("/");
    return { success: true, data: newAccount };
  } catch (err) {
    console.error("createAccountAction error:", err);
    return { success: false, error: err instanceof Error ? err.message : "创建账户失败" };
  }
}

export async function updateAccountAction(
  id: string,
  data: AccountInput
): Promise<{ success: boolean; data?: Account; error?: string }> {
  try {
    const userId = await requireUser();
    const parsed = accountSchema.safeParse(data);
    if (!parsed.success) {
      return { success: false, error: parsed.error.issues[0]?.message || "参数错误" };
    }

    const val = parsed.data;
    const [updated] = await db
      .update(accounts)
      .set({
        name: val.name.trim(),
        accountType: val.accountType,
        balanceType: val.balanceType,
        primaryCurrency: val.primaryCurrency ? val.primaryCurrency.toUpperCase() : null,
        supportedCurrencies: val.supportedCurrencies && val.supportedCurrencies.length > 0 ? val.supportedCurrencies : null,
        remark: val.remark?.trim() || null,
        ext: val.ext?.trim() || null,
        issuerName: val.issuerName?.trim() || null,
        accountNumber: val.accountNumber?.trim() || null,
        platform: val.platform?.trim() || null,
        accountId: val.accountId?.trim() || null,
        location: val.location?.trim() || null,
        updatedAt: new Date(),
      })
      .where(and(eq(accounts.id, id), eq(accounts.userId, userId), isNull(accounts.deletedAt)))
      .returning();

    if (!updated) {
      return { success: false, error: "未找到该账户或无权修改" };
    }

    revalidatePath("/accounts");
    revalidatePath("/channels");
    revalidatePath("/");
    return { success: true, data: updated };
  } catch (err) {
    console.error("updateAccountAction error:", err);
    return { success: false, error: err instanceof Error ? err.message : "更新账户失败" };
  }
}

export async function toggleAccountActiveAction(
  id: string,
  isActive: boolean
): Promise<{ success: boolean; error?: string }> {
  try {
    const userId = await requireUser();
    await db
      .update(accounts)
      .set({
        isActive,
        updatedAt: new Date(),
      })
      .where(and(eq(accounts.id, id), eq(accounts.userId, userId), isNull(accounts.deletedAt)));

    revalidatePath("/accounts");
    return { success: true };
  } catch (err) {
    console.error("toggleAccountActiveAction error:", err);
    return { success: false, error: err instanceof Error ? err.message : "状态切换失败" };
  }
}

export async function deleteAccountAction(
  id: string
): Promise<{ success: boolean; error?: string }> {
  try {
    const userId = await requireUser();
    // 软删除
    const [deleted] = await db
      .update(accounts)
      .set({
        deletedAt: new Date(),
        updatedAt: new Date(),
      })
      .where(and(eq(accounts.id, id), eq(accounts.userId, userId), isNull(accounts.deletedAt)))
      .returning();

    if (!deleted) {
      return { success: false, error: "账户不存在或已删除" };
    }

    revalidatePath("/accounts");
    revalidatePath("/channels");
    revalidatePath("/");
    return { success: true };
  } catch (err) {
    console.error("deleteAccountAction error:", err);
    return { success: false, error: err instanceof Error ? err.message : "删除账户失败" };
  }
}