import { expect, test, type APIRequestContext, type Page } from "@playwright/test";

/**
 * Full pre-delivery QA (browser + hybrid order)
 * Run: pnpm exec playwright test e2e/full-qa.spec.ts --config=playwright.e2e.config.ts --headed
 */
const ADMIN = "http://localhost:5052";
const COMPANY = "http://localhost:5055";
const LANDING = "http://localhost:5050";
const STORE = "http://localhost:5051";
const API = "http://localhost:5053/api/v1";
const OTP = "1234";

const stamp = Date.now().toString().slice(-6);

const companyA = {
  username: `qaA${stamp}`,
  name: `QA Accept ${stamp}`,
  email: `qaA${stamp}@test.com`,
  localPhone: `511${stamp}`,
  password: "Default@123",
  taxNumber: `PLA${stamp}`,
};

const companyB = {
  username: `qaB${stamp}`,
  name: `QA Deny ${stamp}`,
  email: `qaB${stamp}@test.com`,
  localPhone: `512${stamp}`,
  password: "Default@123",
  taxNumber: `PLB${stamp}`,
};

async function adminToken(request: APIRequestContext): Promise<string> {
  const res = await request.post(`${API}/authentication/login`, {
    data: {
      email: "admin@admin.com",
      password: "Default@123",
      fcm: "user",
      role: "ADMIN",
    },
  });
  expect(res.ok(), await res.text()).toBeTruthy();
  const json = await res.json();
  return json.data.accessToken as string;
}

async function bindAdminSession(page: Page, token: string) {
  await page.context().addCookies([
    { name: "token", value: token, url: ADMIN },
    { name: "accountType", value: "ADMIN", url: ADMIN },
  ]);
}

async function registerCompany(page: Page, c: typeof companyA) {
  await page.goto(`${COMPANY}/en/register`, { waitUntil: "networkidle" });
  await page.getByRole("textbox", { name: /company name/i }).fill(c.name);
  await page.getByRole("textbox", { name: /^username$/i }).fill(c.username);
  await expect(page.getByRole("combobox", { name: /country code/i })).toBeVisible();
  await page.getByPlaceholder("512345678").fill(c.localPhone);
  await page.getByRole("textbox", { name: /^email$/i }).fill(c.email);
  await page.getByRole("textbox", { name: /tax number/i }).fill(c.taxNumber);
  await page.getByRole("textbox", { name: /^password$/i }).fill(c.password);
  await page.getByRole("textbox", { name: /^address$/i }).fill("Warsaw");
  await page.getByPlaceholder("512345678").blur();

  const regWait = page.waitForResponse(
    (r) =>
      r.url().includes("/authentication/driver-company/register") &&
      r.request().method() === "POST",
  );
  await page.getByRole("button", { name: /register company/i }).click();
  const reg = await regWait;
  expect(reg.ok(), await reg.text()).toBeTruthy();
  await page.waitForURL(/verify-otp/);

  const otpInput = page.getByRole("textbox", { name: /otp/i });
  await otpInput.click();
  await otpInput.pressSequentially(OTP, { delay: 40 });
  const otpWait = page.waitForResponse((r) =>
    r.url().includes("/authentication/driver-company/verify-otp"),
  );
  await page.getByRole("button", { name: /verify/i }).click();
  const otpRes = await otpWait;
  expect(otpRes.ok(), await otpRes.text()).toBeTruthy();
  await page.waitForURL(/login/);
}

async function setCompanyStatus(
  request: APIRequestContext,
  token: string,
  username: string,
  status: "ACTIVE" | "DENIED",
) {
  const list = await request.get(
    `${API}/admin/driver-companies?search=${username}`,
    { headers: { Authorization: `Bearer ${token}` } },
  );
  expect(list.ok()).toBeTruthy();
  const body = await list.json();
  const row = (body.data ?? []).find((c: { username: string }) => c.username === username);
  expect(row, `company ${username} missing`).toBeTruthy();
  const patch = await request.patch(
    `${API}/admin/driver-companies/${row.id}/status`,
    {
      headers: { Authorization: `Bearer ${token}` },
      data: { status },
    },
  );
  expect(patch.ok(), await patch.text()).toBeTruthy();
  return row.id as number;
}

async function companyLogin(page: Page, username: string, password: string) {
  await page.goto(`${COMPANY}/en/login`, { waitUntil: "networkidle" });
  await page.getByRole("textbox", { name: /username/i }).fill(username);
  await page.locator('input[type="password"]').fill(password);
  const loginWait = page.waitForResponse((r) =>
    r.url().includes("/authentication/driver-company/login"),
  );
  await page.getByRole("button", { name: /sign in|login/i }).click();
  return loginWait;
}

test.describe.serial("FULL QA — pre-delivery", () => {
  test("1) Company A: register → OTP → admin APPROVE → login → vehicle → driver (Select)", async ({
    page,
    request,
  }) => {
    await registerCompany(page, companyA);

    const token = await adminToken(request);
    await bindAdminSession(page, token);

    // UI: status buttons visible on list
    await page.goto(`${ADMIN}/en/users/driver-companies?status=PENDING`, {
      waitUntil: "domcontentloaded",
    });
    await page.waitForTimeout(1500);
    const search = page.locator('input[name="search"]');
    if (await search.count()) {
      await search.fill(companyA.username);
      await search.press("Enter");
      await page.waitForTimeout(1500);
    }
    const row = page.locator("tr", { hasText: companyA.username }).first();
    await expect(row).toBeVisible({ timeout: 30_000 });
    await expect(row.getByRole("button", { name: /^ACTIVE$/i })).toBeVisible();
    await expect(row.getByRole("button", { name: /^DENIED$/i })).toBeVisible();
    await row.getByRole("button", { name: /^ACTIVE$/i }).click();
    await page.waitForTimeout(1000);

    // Guarantee ACTIVE for rest of flow
    await setCompanyStatus(request, token, companyA.username, "ACTIVE");

    const loginRes = await companyLogin(page, companyA.username, companyA.password);
    expect((await loginRes).ok()).toBeTruthy();
    await expect(page).not.toHaveURL(/login/, { timeout: 30_000 });

    // Vehicle
    await page.goto(`${COMPANY}/en/vehicles/new`, { waitUntil: "domcontentloaded" });
    const inputs = page.locator("form input:not([type=file]):not([type=hidden])");
    const vals = ["Toyota", "Corolla", "2023", "Black", `QA${stamp}`, "4"];
    for (let i = 0; i < Math.min(await inputs.count(), vals.length); i++) {
      await inputs.nth(i).fill(vals[i]);
    }
    await page.locator('input[type="file"]').setInputFiles({
      name: "vehicle.png",
      mimeType: "image/png",
      buffer: Buffer.from(
        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==",
        "base64",
      ),
    });
    await expect(page.locator("form img")).toHaveCount(1, { timeout: 20_000 });
    await page.getByRole("button", { name: /save/i }).click();
    await page.waitForTimeout(2000);
    await page.goto(`${COMPANY}/en/vehicles`);
    await expect(page.getByText(/Toyota|Corolla|QA/i).first()).toBeVisible({
      timeout: 20_000,
    });

    // Driver with selects
    await page.goto(`${COMPANY}/en/drivers/new`, { waitUntil: "domcontentloaded" });
    const tier = page.locator('select[name="tierId"]');
    await expect(page.locator('select[name="cityId"]')).toHaveCount(0);
    await expect(tier).toBeVisible();
    await expect.poll(async () => tier.locator("option").count()).toBeGreaterThan(1);

    await page.locator('input[name="firstName"]').fill("Khaled");
    await page.locator('input[name="lastName"]').fill("Fleet");
    await page.getByPlaceholder("512345678").fill(`513${stamp}`);
    await page.locator('input[name="email"]').fill(`khaled${stamp}@test.com`);
    await page.locator('input[name="password"]').fill("Default@123");
    await page.locator('input[name="identifyNumber"]').fill(`ID${stamp}`);
    await page.locator('input[name="licenseNumber"]').fill(`LIC${stamp}`);
    await page.locator('input[name="licenseExpiry"]').fill("2030-12-31");
    await page.locator('input[name="idExpiry"]').fill("2030-12-31");
    await tier.selectOption({ index: 1 });
    const png = {
      name: "doc.png",
      mimeType: "image/png",
      buffer: Buffer.from(
        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==",
        "base64",
      ),
    };
    const fileInputs = page.locator('input[type="file"]');
    for (let i = 0; i < (await fileInputs.count()); i++) {
      await fileInputs.nth(i).setInputFiles(png);
    }
    await expect(page.locator("form img")).toHaveCount(6, { timeout: 20_000 });
    await page.getByRole("button", { name: /save/i }).click();
    await page.waitForTimeout(3000);
    await page.goto(`${COMPANY}/en/drivers`);
    await expect(page.getByText("Khaled").first()).toBeVisible({ timeout: 25_000 });
  });

  test("2) Company B: register → OTP → admin DENY → login FAILS", async ({
    page,
    request,
  }) => {
    await registerCompany(page, companyB);
    const token = await adminToken(request);
    await bindAdminSession(page, token);

    await page.goto(`${ADMIN}/en/users/driver-companies?status=PENDING`, {
      waitUntil: "domcontentloaded",
    });
    await page.waitForTimeout(1500);
    const search = page.locator('input[name="search"]');
    if (await search.count()) {
      await search.fill(companyB.username);
      await search.press("Enter");
      await page.waitForTimeout(1500);
    }
    const row = page.locator("tr", { hasText: companyB.username }).first();
    await expect(row).toBeVisible({ timeout: 30_000 });
    await row.getByRole("button", { name: /^DENIED$/i }).click();
    await page.waitForTimeout(1000);
    await setCompanyStatus(request, token, companyB.username, "DENIED");

    const loginRes = await companyLogin(page, companyB.username, companyB.password);
    const res = await loginRes;
    expect(res.ok()).toBeFalsy();
    await expect(page).toHaveURL(/login/);
    await expect(
      page.getByText(/not active|denied|verify|pending|غير نشط|مرفوض/i).first(),
    ).toBeVisible({ timeout: 15_000 });
  });

  test("3) Independent delivery: admin create uses Select masters; list loads", async ({
    page,
    request,
  }) => {
    const token = await adminToken(request);
    await bindAdminSession(page, token);

    await page.goto(`${ADMIN}/en/users/delivery/create`, {
      waitUntil: "domcontentloaded",
    });
    await page.waitForTimeout(2000);

    // No raw ID text inputs for masters
    await expect(
      page.locator(
        'input[name="countryId"][type="text"], input[name="cityId"][type="text"], input[name="zoneId"][type="text"], input[name="nationalityId"][type="text"]',
      ),
    ).toHaveCount(0);

    await page.goto(`${LANDING}/en/register-delivery`, {
      waitUntil: "domcontentloaded",
    });
    await page.waitForTimeout(2000);
    await expect(
      page.locator(
        'input[name="countryId"][type="text"], input[name="cityId"][type="number"]',
      ),
    ).toHaveCount(0);
    await expect
      .poll(async () =>
        page.locator("select, [role='combobox'], [aria-haspopup='listbox']").count(),
      )
      .toBeGreaterThan(0);

    await page.goto(`${ADMIN}/en/users/delivery`, { waitUntil: "domcontentloaded" });
    await expect(page.locator("body")).toBeVisible();
  });

  test("4) Order cycle (hybrid): TAKE_AWAY create → accept → DELIVERED → store UI", async ({
    request,
    page,
  }) => {
    const prodLookup = await request.get(`${API}/product?search=QA%20Product&limit=5`);
    let productId = 1;
    if (prodLookup.ok()) {
      const body = await prodLookup.json();
      if (Array.isArray(body.data) && body.data[0]?.id) productId = body.data[0].id;
    }

    const phone = `+48 520${stamp}`;
    await request.post(`${API}/authentication/requestLoginOTP`, {
      data: { phone, role: "CUSTOMER" },
    });
    const custLogin = await request.post(`${API}/authentication/login`, {
      data: { phone, role: "CUSTOMER", otp: OTP, fcm: "user" },
    });
    expect(custLogin.ok(), await custLogin.text()).toBeTruthy();
    const custToken = (await custLogin.json()).data.accessToken as string;

    const orderRes = await request.post(`${API}/order`, {
      headers: { Authorization: `Bearer ${custToken}` },
      data: {
        items: [{ productId, quantity: 1 }],
        storeId: 1,
        couponsId: [],
        deliveryStatus: "TAKE_AWAY",
        payWithWallet: false,
        paymentMethod: "CASH",
      },
    });
    const orderText = await orderRes.text();
    test.info().annotations.push({
      type: "order-create",
      description: `status=${orderRes.status()} productId=${productId} body=${orderText.slice(0, 400)}`,
    });
    expect(
      orderRes.ok(),
      `Order create failed (${orderRes.status()}): ${orderText.slice(0, 300)}`,
    ).toBeTruthy();
    const orderPayload = JSON.parse(orderText).data;
    const orderId = (orderPayload?.orderId ?? orderPayload?.id) as number;
    expect(orderId, `missing order id in ${orderText.slice(0, 200)}`).toBeTruthy();

    const vendorLogin = await request.post(`${API}/authentication/login`, {
      data: {
        email: "store@store.com",
        password: "Default@123",
        fcm: "user",
        role: "VENDOR",
      },
    });
    expect(vendorLogin.ok(), await vendorLogin.text()).toBeTruthy();
    const vendorToken = (await vendorLogin.json()).data.accessToken as string;

    // Vendor accept → HANDED_OVER
    const accept = await request.patch(`${API}/order/${orderId}`, {
      headers: { Authorization: `Bearer ${vendorToken}` },
      data: { status: "ACCEPTED" },
    });
    expect(accept.ok(), await accept.text()).toBeTruthy();

    // Complete TAKE_AWAY
    const deliver = await request.patch(`${API}/order/${orderId}`, {
      headers: { Authorization: `Bearer ${vendorToken}` },
      data: { status: "DELIVERED" },
    });
    expect(deliver.ok(), await deliver.text()).toBeTruthy();

    const check = await request.get(`${API}/order/${orderId}`, {
      headers: { Authorization: `Bearer ${vendorToken}` },
    });
    expect(check.ok(), await check.text()).toBeTruthy();
    expect((await check.json()).data?.status).toBe("DELIVERED");

    // Store portal login smoke
    await page.goto(`${STORE}/en/signin`, { waitUntil: "domcontentloaded" });
    await expect(page.locator("body")).toBeVisible();
    const email = page.getByRole("textbox", { name: /email/i });
    if (await email.count()) {
      await email.fill("store@store.com");
      await page.locator('input[type="password"]').fill("Default@123");
      await page.getByRole("button", { name: /sign in|login/i }).click();
      await page.waitForTimeout(2500);
    }
    await expect(page.locator("body")).toBeVisible();
  });
});
