import {
  code,
  List,
  Output,
  refkey,
  render,
  StatementList,
} from "@alloy-js/core";
import { describe, expect, it } from "vitest";

import { InterfaceMember, ObjectExpression } from "../src/components/index.js";
import { MemberExpression } from "../src/components/MemberExpression.jsx";
import { VarDeclaration } from "../src/components/VarDeclaration.jsx";
import type { ParameterDescriptor } from "../src/index.js";
import {
  ClassDeclaration,
  ClassField,
  FunctionDeclaration,
  InterfaceDeclaration,
  ObjectProperty,
  SourceFile,
} from "../src/index.js";
import { TestFile } from "./utils.js";

it("renders basic member expression with dot notation", () => {
  expect(
    <TestFile>
      <MemberExpression>
        <MemberExpression.Part id="obj" />
        <MemberExpression.Part id="property" />
      </MemberExpression>
    </TestFile>,
  ).toRenderTo(`
    obj.property
  `);
});

it("renders basic member expression with numeric id", () => {
  expect(
    <TestFile>
      <MemberExpression>
        <MemberExpression.Part id="arr" />
        <MemberExpression.Part id={0} />
        <MemberExpression.Part id="foo-bar" />
      </MemberExpression>
    </TestFile>,
  ).toRenderTo(`
    arr[0]["foo-bar"]
  `);
});

it("renders basic member expression with index", () => {
  expect(
    <TestFile>
      <MemberExpression>
        <MemberExpression.Part id="arr" />
        <MemberExpression.Part index={0} />
        <MemberExpression.Part id="foo-bar" />
      </MemberExpression>
    </TestFile>,
  ).toRenderTo(`
    arr[0]["foo-bar"]
  `);
});

it("renders basic member expression with numeric children", () => {
  expect(
    <TestFile>
      <MemberExpression>
        <MemberExpression.Part id="arr" />
        <MemberExpression.Part>0</MemberExpression.Part>
        <MemberExpression.Part id="foo-bar" />
      </MemberExpression>
    </TestFile>,
  ).toRenderTo(`
    arr[0]["foo-bar"]
  `);
});

it("renders basic member expression with string children", () => {
  expect(
    <TestFile>
      <MemberExpression>
        <MemberExpression.Part id="arr" />
        <MemberExpression.Part>"0"</MemberExpression.Part>
        <MemberExpression.Part id="foo-bar" />
      </MemberExpression>
    </TestFile>,
  ).toRenderTo(`
    arr["0"]["foo-bar"]
  `);
});

it("renders basic member expression with an expression index", () => {
  const xRefkey = refkey();
  expect(
    <TestFile>
      <StatementList>
        <VarDeclaration name="x" initializer={1} refkey={xRefkey} />
        <MemberExpression>
          <MemberExpression.Part id="arr" />
          <MemberExpression.Part>{xRefkey} + 1</MemberExpression.Part>
          <MemberExpression.Part id="foo-bar" />
        </MemberExpression>
      </StatementList>
    </TestFile>,
  ).toRenderTo(`
    const x = 1;
    arr[x + 1]["foo-bar"];
  `);
});

it("renders basic member expression with an expression id", () => {
  expect(
    <TestFile>
      <StatementList>
        <MemberExpression>
          <MemberExpression.Part id="arr" />
          <MemberExpression.Part>"foo" + 1</MemberExpression.Part>
          <MemberExpression.Part id="foo-bar" />
        </MemberExpression>
      </StatementList>
    </TestFile>,
  ).toRenderTo(`
    arr["foo" + 1]["foo-bar"];
  `);
});

it("renders member expression with bracket notation for invalid identifiers", () => {
  expect(
    <TestFile>
      <MemberExpression>
        <MemberExpression.Part id="obj" />
        <MemberExpression.Part id="property-name" />
      </MemberExpression>
    </TestFile>,
  ).toRenderTo(`
    obj["property-name"]
  `);
});

it("renders member expressions with quotes", () => {
  expect(
    <TestFile>
      <MemberExpression>
        <MemberExpression.Part id="obj" />
        <MemberExpression.Part id={`property-"name"`} />
      </MemberExpression>
    </TestFile>,
  ).toRenderTo(`
    obj["property-\\"name\\""]
  `);
});

it("handles nullish chaining", () => {
  expect(
    <TestFile>
      <MemberExpression>
        <MemberExpression.Part id="obj" nullish={true} />
        <MemberExpression.Part id="property" />
      </MemberExpression>
    </TestFile>,
  ).toRenderTo(`
    obj?.property
  `);
});

it("supports multiple levels of nesting", () => {
  expect(
    <TestFile>
      <MemberExpression>
        <MemberExpression.Part id="a" />
        <MemberExpression.Part id="b" />
        <MemberExpression.Part id="c" />
        <MemberExpression.Part id="d" />
      </MemberExpression>
    </TestFile>,
  ).toRenderTo(`
    a.b.c.d
  `);
});

it("ignores non-part children", () => {
  expect(
    <TestFile>
      <MemberExpression>
        <MemberExpression.Part id="obj" />
        <MemberExpression.Part id="property" />
      </MemberExpression>
    </TestFile>,
  ).toRenderTo(`
    obj.property
  `);
});

it("ignores allows parts to define children", () => {
  expect(
    <TestFile>
      <MemberExpression>
        <MemberExpression.Part>well</MemberExpression.Part>
        <MemberExpression.Part>hello</MemberExpression.Part>
      </MemberExpression>
    </TestFile>,
  ).toRenderTo(`
    well.hello
  `);
});

it("flattens nested member expressions", () => {
  expect(
    <TestFile>
      <MemberExpression>
        <MemberExpression.Part id="outer" />
        <MemberExpression>
          <MemberExpression.Part id="inner" />
          <MemberExpression.Part id="prop" />
        </MemberExpression>
        <MemberExpression.Part id="last" />
      </MemberExpression>
    </TestFile>,
  ).toRenderTo(`
    outer.inner.prop.last
  `);
});

it("handles a mix of dot and bracket notation", () => {
  expect(
    <TestFile>
      <MemberExpression>
        <MemberExpression.Part id="obj" />
        <MemberExpression.Part id="normalProp" />
        <MemberExpression.Part id="special-prop" />
        <MemberExpression.Part id="123" />
      </MemberExpression>
    </TestFile>,
  ).toRenderTo(`
    obj.normalProp["special-prop"]["123"]
  `);
});

it("handles nullish chaining at multiple levels", () => {
  expect(
    <TestFile>
      <MemberExpression>
        <MemberExpression.Part id="a" />
        <MemberExpression.Part id="b" nullish={true} />
        <MemberExpression.Part id="c" />
        <MemberExpression.Part id="d" nullish={true} />
        <MemberExpression.Part id="e" />
      </MemberExpression>
    </TestFile>,
  ).toRenderTo(`
    a.b?.c.d?.e
  `);
});

it("throws an error when providing conflicting part props", () => {
  expect(() =>
    render(
      <TestFile>
        <MemberExpression>
          <MemberExpression.Part id="obj" />
          <MemberExpression.Part id="property" nullish={true} args={[1, 2]} />
        </MemberExpression>
      </TestFile>,
      { insertFinalNewLine: false },
    ),
  ).toThrowError(
    `Only one of args, id can be used for a MemberExpression part at a time`,
  );
});

it("takes children for the id part", () => {
  expect(
    <TestFile>
      <List>
        <MemberExpression>
          <MemberExpression.Part>child1</MemberExpression.Part>
          <MemberExpression.Part quoteId>child2</MemberExpression.Part>
        </MemberExpression>
        <MemberExpression>
          <MemberExpression.Part>child1</MemberExpression.Part>
          <MemberExpression.Part quoteId>child2</MemberExpression.Part>
          <MemberExpression.Part args />
          <MemberExpression.Part quoteId nullish>
            child3
          </MemberExpression.Part>
          <MemberExpression.Part args />
          <MemberExpression.Part>"foo" + 1</MemberExpression.Part>
          <MemberExpression.Part args />
        </MemberExpression>
      </List>
    </TestFile>,
  ).toRenderTo(`
    child1["child2"]
    child1["child2"]()["child3"]?.()["foo" + 1]()
  `);
});

describe("with refkeys", () => {
  it("handles symbols correctly", () => {
    const rk1 = refkey();
    const rk2 = refkey();
    expect(
      <TestFile>
        <StatementList>
          <VarDeclaration name="test1" refkey={rk1} initializer={1} />
          <VarDeclaration name="test1" refkey={rk2} initializer={2} />
          <MemberExpression>
            <MemberExpression.Part refkey={rk1} />
            <MemberExpression.Part refkey={rk2} />
          </MemberExpression>
        </StatementList>
      </TestFile>,
    ).toRenderTo(`
      const test1 = 1;
      const test1_2 = 2;
      test1.test1_2;
    `);
  });

  it("handles nullish symbols correctly", () => {
    // Note that this is deliberately producing invalid references (it's just easiest to test with VarDeclaration).
    const rk1 = refkey();
    const rk2 = refkey();
    expect(
      <TestFile>
        <StatementList>
          <VarDeclaration name="test1" refkey={rk1} initializer={1} nullish />
          <VarDeclaration name="test1" refkey={rk2} initializer={2} nullish />
          <MemberExpression>
            <MemberExpression.Part refkey={rk1} />
            <MemberExpression.Part refkey={rk2} />
          </MemberExpression>
        </StatementList>
      </TestFile>,
    ).toRenderTo(`
      const test1 = 1;
      const test1_2 = 2;
      test1?.test1_2;
    `);
  });

  it("handles optional parameters correctly", () => {
    const fooRef = refkey();
    const modelRef = refkey();
    const parameters: ParameterDescriptor[] = [
      { name: "foo", optional: true, refkey: fooRef, type: modelRef },
    ];
    const messageRef = refkey();
    const template = (
      <List hardline>
        <InterfaceDeclaration name="Model" refkey={modelRef}>
          <InterfaceMember name="bar" refkey={refkey()} type="string" />
        </InterfaceDeclaration>
        <FunctionDeclaration name="fooFunction" parameters={parameters}>
          <StatementList>
            <VarDeclaration
              name="message"
              const
              refkey={messageRef}
              initializer={
                <MemberExpression>
                  <MemberExpression.Part refkey={fooRef} />
                  <MemberExpression.Part id="bar" />
                </MemberExpression>
              }
            />
            <>console.log({messageRef})</>
          </StatementList>
        </FunctionDeclaration>
      </List>
    );

    expect(<TestFile>{template}</TestFile>).toRenderTo(`
      interface Model {
        bar: string
      }
      function fooFunction(foo?: Model) {
        const message = foo?.bar;
        console.log(message);
      }
    `);
  });

  it("handles nullish parameters correctly", () => {
    const fooRef = refkey();
    const modelRef = refkey();
    const parameters: ParameterDescriptor[] = [
      {
        name: "foo",
        nullish: true,
        refkey: fooRef,
        type: <>{modelRef} | null</>,
      },
    ];
    const messageRef = refkey();
    const template = (
      <List hardline>
        <InterfaceDeclaration name="Model" refkey={modelRef}>
          <InterfaceMember name="bar" refkey={refkey()} type="string" />
        </InterfaceDeclaration>
        <FunctionDeclaration name="fooFunction" parameters={parameters}>
          <StatementList>
            <VarDeclaration
              name="message"
              const
              refkey={messageRef}
              initializer={
                <MemberExpression>
                  <MemberExpression.Part refkey={fooRef} />
                  <MemberExpression.Part id="bar" />
                </MemberExpression>
              }
            />
            <>console.log({messageRef})</>
          </StatementList>
        </FunctionDeclaration>
      </List>
    );

    expect(<TestFile>{template}</TestFile>).toRenderTo(`
      interface Model {
        bar: string
      }
      function fooFunction(foo: Model | null) {
        const message = foo?.bar;
        console.log(message);
      }
    `);
  });

  it("handles nullish class member correctly", () => {
    const classRefkey = refkey();
    const interfaceRefkey = refkey();
    const interfaceMemberRefkey = refkey();
    const classMemberRefkey = refkey();
    const instanceRefkey = refkey();
    expect(
      <TestFile>
        <List hardline>
          <InterfaceDeclaration name="Bar" refkey={interfaceRefkey}>
            <InterfaceMember
              name="prop1"
              refkey={interfaceMemberRefkey}
              type={"string"}
            />
          </InterfaceDeclaration>
          <ClassDeclaration name="Foo" refkey={classRefkey}>
            <ClassField
              name="test1"
              refkey={classMemberRefkey}
              nullish
              type={interfaceRefkey}
            />
          </ClassDeclaration>
          <VarDeclaration
            name="inst"
            refkey={instanceRefkey}
            initializer={code`new ${classRefkey}();`}
          />
          <MemberExpression>
            <MemberExpression.Part refkey={instanceRefkey} />
            <MemberExpression.Part refkey={classMemberRefkey} />
            <MemberExpression.Part refkey={interfaceMemberRefkey} />
          </MemberExpression>
        </List>
      </TestFile>,
    ).toRenderTo(`
       interface Bar {
         prop1: string
       }
       class Foo {
         test1: Bar
       }
       const inst = new Foo();
       inst.test1?.prop1
    `);
  });

  it("handles late resolved refkeys correctly", () => {
    const rk1 = refkey();
    const rk2 = refkey();
    expect(
      <TestFile>
        <StatementList>
          <MemberExpression>
            <MemberExpression.Part refkey={rk1} />
            <MemberExpression.Part refkey={rk2} />
          </MemberExpression>
          <VarDeclaration name="test1" refkey={rk1} initializer={1} />
          <VarDeclaration name="test1" refkey={rk2} initializer={2} />
        </StatementList>
      </TestFile>,
    ).toRenderTo(`
      test1.test1_2;
      const test1 = 1;
      const test1_2 = 2;
    `);
  });

  it("creates a full reference to the first refkey", () => {
    const rk1 = refkey();
    expect(
      <Output>
        <SourceFile path="source.ts">
          <VarDeclaration name="importMe">
            <ObjectExpression>
              <ObjectProperty name="prop" refkey={rk1} />
            </ObjectExpression>
          </VarDeclaration>
        </SourceFile>
        <SourceFile path="index.ts">
          <StatementList>
            <MemberExpression>
              <MemberExpression.Part refkey={rk1} />
              <MemberExpression.Part id="foo" />
            </MemberExpression>
            <MemberExpression>
              <MemberExpression.Part>{rk1}</MemberExpression.Part>
              <MemberExpression.Part id="foo" />
            </MemberExpression>
          </StatementList>
        </SourceFile>
      </Output>,
    ).toRenderTo({
      "index.ts": `
        import { importMe } from "./source.js";

        importMe.prop.foo;
        importMe.prop.foo;
      `,
      "source.ts": expect.anything(),
    });
  });
});

describe("with function calls", () => {
  it("handles simple function calls correctly", () => {
    expect(
      <TestFile>
        <MemberExpression>
          <MemberExpression.Part id="myFunction" />
          <MemberExpression.Part args={[1, 2]} />
        </MemberExpression>
      </TestFile>,
    ).toRenderTo(`
      myFunction(1, 2)
    `);
  });

  it("handles nullish function calls correctly", () => {
    expect(
      <TestFile>
        <MemberExpression>
          <MemberExpression.Part id="method1" nullish />
          <MemberExpression.Part nullish args={[1, 2]} />
          <MemberExpression.Part nullish args={[]} />
          <MemberExpression.Part id="method2" nullish />
          <MemberExpression.Part args={[]} />
          <MemberExpression.Part id="prop" />
        </MemberExpression>
      </TestFile>,
    ).toRenderTo(`
      method1?.(1, 2)?.()?.method2?.().prop
    `);
  });

  it("handles function calls returning nullish correctly", () => {
    expect(
      <TestFile>
        <MemberExpression>
          <MemberExpression.Part id="myFunction" />
          <MemberExpression.Part args={[1, 2]} nullish />
          <MemberExpression.Part id="prop" />
        </MemberExpression>
      </TestFile>,
    ).toRenderTo(`
      myFunction(1, 2)?.prop
    `);
  });

  it("handles function calls returning nullish correctly", () => {
    expect(
      <TestFile>
        <MemberExpression>
          <MemberExpression.Part id="myFunction" />
          <MemberExpression.Part args={[1, 2]} nullish />
          <MemberExpression.Part id="prop" />
        </MemberExpression>
      </TestFile>,
    ).toRenderTo(`
      myFunction(1, 2)?.prop
    `);
  });
});

describe("formatting", () => {
  describe("simple chains", () => {
    it("just dots", () => {
      expect(
        <TestFile>
          <MemberExpression>
            <MemberExpression.Part id="four" />
            <MemberExpression.Part id="four" />
            <MemberExpression.Part id="four" />
            <MemberExpression.Part id="four" />
            <MemberExpression.Part id="four" />
            <MemberExpression.Part id="four" />
          </MemberExpression>
        </TestFile>,
      ).toRenderTo(
        `
        four.four
          .four.four
          .four.four
      `,
        { printWidth: 12 },
      );
    });

    it("bracket breaks", () => {
      expect(
        <TestFile>
          <MemberExpression>
            <MemberExpression.Part id="obj" />
            <MemberExpression.Part id="property-name" />
            <MemberExpression.Part id="prop" />
          </MemberExpression>
        </TestFile>,
      ).toRenderTo(
        `
        obj[
          "property-name"
        ].prop
      `,
        { printWidth: 12 },
      );
    });
  });

  describe("call chains", () => {
    it("handles single calls", () => {
      expect(
        <TestFile>
          <MemberExpression>
            <MemberExpression.Part id="z" />
            <MemberExpression.Part id="object" />
            <MemberExpression.Part
              args={[<ObjectExpression jsValue={{ x: 1 }} />]}
            />
          </MemberExpression>
        </TestFile>,
      ).toRenderTo(
        `
        z.object({
          x: 1,
        })
      `,
        { printWidth: 12 },
      );
    });
    it("handles single calls with multiple parameters", () => {
      expect(
        <TestFile>
          <MemberExpression>
            <MemberExpression.Part id="z" />
            <MemberExpression.Part id="object" />
            <MemberExpression.Part
              args={[
                <ObjectExpression jsValue={{ x: 1 }} />,
                <ObjectExpression jsValue={{ y: 2 }} />,
              ]}
            />
          </MemberExpression>
        </TestFile>,
      ).toRenderTo(
        `
        z.object(
          {
            x: 1,
          },
          {
            y: 2,
          }
        )
      `,
        { printWidth: 12 },
      );
    });
    it("handles multiple calls", () => {
      expect(
        <TestFile>
          <MemberExpression>
            <MemberExpression.Part id="z" />
            <MemberExpression.Part id="object" />
            <MemberExpression.Part
              args={[<ObjectExpression jsValue={{ x: 1 }} />]}
            />
            <MemberExpression.Part id="partial" />
            <MemberExpression.Part args={[]} />
          </MemberExpression>
        </TestFile>,
      ).toRenderTo(
        `
        z
          .object({
            x: 1,
          })
          .partial()
      `,
        { printWidth: 12 },
      );
    });

    it("renders multiple calls on the same line when there are no breaks and they fit", () => {
      expect(
        <TestFile>
          <MemberExpression>
            <MemberExpression.Part id="z" />
            <MemberExpression.Part id="object" />
            <MemberExpression.Part args />
            <MemberExpression.Part id="partial" />
            <MemberExpression.Part args />
            <MemberExpression.Part id="optional" />
            <MemberExpression.Part args />
          </MemberExpression>
        </TestFile>,
      ).toRenderTo(`
        z.object().partial().optional()
      `);
    });
    it("handles multiple calls with id parts", () => {
      expect(
        <TestFile>
          <MemberExpression>
            <MemberExpression.Part id="z" />
            <MemberExpression.Part id="z1" nullish />
            <MemberExpression.Part id="object" />
            <MemberExpression.Part
              args={[<ObjectExpression jsValue={{ x: 1 }} />]}
            />
            <MemberExpression.Part id="foo" />
            <MemberExpression.Part id="partial" />
            <MemberExpression.Part args={[]} />
          </MemberExpression>
        </TestFile>,
      ).toRenderTo(`
        z.z1
          ?.object({
            x: 1,
          })
          .foo.partial()
      `);
    });

    it("handles the first part being a call", () => {
      expect(
        <TestFile>
          <MemberExpression>
            <MemberExpression.Part id="z" />
            <MemberExpression.Part args />
            <MemberExpression.Part id="z1" nullish />
            <MemberExpression.Part id="object" />
            <MemberExpression.Part
              args={[<ObjectExpression jsValue={{ x: 1 }} />]}
            />
            <MemberExpression.Part id="foo" />
            <MemberExpression.Part id="partial" />
            <MemberExpression.Part args={[]} />
          </MemberExpression>
        </TestFile>,
      ).toRenderTo(`
        z()
          .z1?.object({
            x: 1,
          })
          .foo.partial()
      `);
    });
  });
});

describe("with await", () => {
  it("renders member expression with await", () => {
    expect(
      <TestFile>
        <MemberExpression>
          <MemberExpression.Part id="foo" />
          <MemberExpression.Part id="bar" />
          <MemberExpression.Part args await />
          <MemberExpression.Part id="baz" />
        </MemberExpression>
      </TestFile>,
    ).toRenderTo(`
      (await foo.bar()).baz
    `);
  });

  it("renders member expression with await at the end", () => {
    expect(
      <TestFile>
        <MemberExpression>
          <MemberExpression.Part id="foo" />
          <MemberExpression.Part id="bar" />
          <MemberExpression.Part args await />
        </MemberExpression>
      </TestFile>,
    ).toRenderTo(`
      await foo.bar()
    `);
  });

  it("renders member expression with await in the middle of property access", () => {
    expect(
      <TestFile>
        <MemberExpression>
          <MemberExpression.Part id="foo" />
          <MemberExpression.Part id="bar" await />
          <MemberExpression.Part id="baz" />
        </MemberExpression>
      </TestFile>,
    ).toRenderTo(`
      (await foo.bar).baz
    `);
  });

  it("renders member expression with multiple awaits", () => {
    expect(
      <TestFile>
        <MemberExpression>
          <MemberExpression.Part id="foo" />
          <MemberExpression.Part id="bar" await />
          <MemberExpression.Part id="baz" await />
          <MemberExpression.Part id="qux" />
        </MemberExpression>
      </TestFile>,
    ).toRenderTo(`
      (await (await foo.bar).baz).qux
    `);
  });

  it("renders member expression with await and call chain (disables formatting)", () => {
    expect(
      <TestFile>
        <MemberExpression>
          <MemberExpression.Part id="foo" />
          <MemberExpression.Part id="bar" />
          <MemberExpression.Part args />
          <MemberExpression.Part id="baz" />
          <MemberExpression.Part args await />
          <MemberExpression.Part id="qux" />
          <MemberExpression.Part args />
        </MemberExpression>
      </TestFile>,
    ).toRenderTo(`
      (await foo.bar().baz()).qux()
    `);
  });
});