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

import { ClassField } from "../src/components/stc/index.js";
import {
  ClassDeclaration,
  FunctionDeclaration,
  InterfaceDeclaration,
  InterfaceMember,
  SourceFile,
  TypeDeclaration,
  VarDeclaration,
} from "../src/index.js";
import type { ParameterDescriptor } from "../src/parameter-descriptor.js";
import { TestFile } from "./utils.js";

it("works", () => {
  expect(
    <TestFile>
      <FunctionDeclaration name="foo" />
    </TestFile>,
  ).toRenderTo(`
      function foo() {}
    `);
});

it("can be exported", () => {
  expect(
    <TestFile>
      <FunctionDeclaration export name="foo" />
    </TestFile>,
  ).toRenderTo(`
      export function foo() {}
    `);
});

it("can be a default export", () => {
  expect(
    <TestFile>
      <FunctionDeclaration export default name="foo" />
    </TestFile>,
  ).toRenderTo(`
      export default function foo() {}
    `);
});

it("can be an async function", () => {
  expect(
    <TestFile>
      <FunctionDeclaration async export name="foo" />
    </TestFile>,
  ).toRenderTo(`
    export async function foo() {}
  `);
});

it("can be an async function with returnType", () => {
  expect(
    <TestFile>
      <FunctionDeclaration async export name="foo" returnType="Foo" />
    </TestFile>,
  ).toRenderTo(`
    export async function foo(): Promise<Foo> {}
  `);
});

it("can be an async function with returnType element", () => {
  function Foo(_props?: Props) {
    return <>Foo</>;
  }
  expect(
    <TestFile>
      <FunctionDeclaration async export name="foo" returnType={<Foo />} />
    </TestFile>,
  ).toRenderTo(`
    export async function foo(): Promise<Foo> {}
  `);
});

it("supports parameters by element", () => {
  const decl = (
    <FunctionDeclaration name="foo">
      return a + b;
      <FunctionDeclaration.Parameters>a, b</FunctionDeclaration.Parameters>
    </FunctionDeclaration>
  );

  expect(<TestFile>{decl}</TestFile>).toRenderTo(`
    function foo(a, b) {
      return a + b;
    }
  `);
});

it("supports type parameters by descriptor object", () => {
  const decl = (
    <FunctionDeclaration
      name="foo"
      typeParameters={[
        { name: "a", extends: "any" },
        { name: "b", extends: "any" },
      ]}
    ></FunctionDeclaration>
  );

  expect(<TestFile>{decl}</TestFile>).toRenderTo(`
    function foo<a extends any, b extends any>() {}
  `);
});
it("supports type parameters with namekeys", () => {
  const decl = (
    <FunctionDeclaration
      name="foo"
      typeParameters={[
        { name: namekey("a"), extends: "any" },
        { name: namekey("b"), extends: "any" },
      ]}
    ></FunctionDeclaration>
  );

  expect(<TestFile>{decl}</TestFile>).toRenderTo(`
    function foo<a extends any, b extends any>() {}
  `);
});
it("supports type parameters by descriptor array", () => {
  const decl = (
    <FunctionDeclaration
      name="foo"
      typeParameters={["a", "b"]}
    ></FunctionDeclaration>
  );

  expect(<TestFile>{decl}</TestFile>).toRenderTo(`
    function foo<a, b>() {}
  `);
});

it("supports type parameters by element", () => {
  const decl = (
    <FunctionDeclaration name="foo">
      <FunctionDeclaration.TypeParameters>
        a, b
      </FunctionDeclaration.TypeParameters>
    </FunctionDeclaration>
  );

  expect(<TestFile>{decl}</TestFile>).toRenderTo(`
    function foo<a, b>() {}
  `);
});

it("resolves references to function-local symbols from deeply indented code blocks (#429)", () => {
  const value = refkey();
  expect(
    <TestFile>
      <FunctionDeclaration
        export
        name="serialize"
        parameters={[{ name: "value", type: "string | null", refkey: value }]}
        returnType="string"
      >
        {code`
          if (value) {
            if (!${value}) {
              return ${value} as any;
            }
          }
          return ${value};
        `}
      </FunctionDeclaration>
    </TestFile>,
  ).toRenderTo(`
    export function serialize(value: string | null): string {
      if (value) {
        if (!value) {
          return value as any;
        }
      }
      return value;
    }
  `);
});

it("do not add an extra comma when there is no parameters", () => {
  expect(
    <TestFile>
      <FunctionDeclaration name="thisFunctionNameIsTooLongSoTheFormatterWillInsertLineBreakAndIfBreakNodes"></FunctionDeclaration>
    </TestFile>,
  ).toRenderTo(`
    function thisFunctionNameIsTooLongSoTheFormatterWillInsertLineBreakAndIfBreakNodes() {

    }
  `);
});

it("resolves references to function-local symbols from indented code blocks (#429)", () => {
  const value = refkey();
  expect(
    <TestFile>
      <FunctionDeclaration
        export
        name="serialize"
        parameters={[{ name: "value", type: "string | null", refkey: value }]}
        returnType="string"
      >
        {code`
          if (!${value}) {
            return ${value} as any;
          }
          return ${value};
        `}
      </FunctionDeclaration>
    </TestFile>,
  ).toRenderTo(`
    export function serialize(value: string | null): string {
      if (!value) {
        return value as any;
      }
      return value;
    }
  `);
});

describe("symbols", () => {
  it("creates a nested scope", () => {
    const innerRefkey = refkey();
    const outerRefkey = refkey();
    const decl = (
      <StatementList>
        <FunctionDeclaration name="foo">
          <StatementList>
            {innerRefkey}
            <VarDeclaration name="refme" refkey={innerRefkey}>
              1
            </VarDeclaration>
          </StatementList>
        </FunctionDeclaration>
        <VarDeclaration name="refme" refkey={outerRefkey}>
          2
        </VarDeclaration>
        {outerRefkey}
      </StatementList>
    );
    expect(<TestFile>{decl}</TestFile>).toRenderTo(`
      function foo() {
        refme;
        const refme = 1;
      };
      const refme = 2;
      refme;
    `);
  });

  it("throws an error when trying to access a symbol in a nested function scope", () => {
    const innerRefkey = refkey();
    const decl = (
      <>
        <FunctionDeclaration name="foo">
          <VarDeclaration name="refme" refkey={innerRefkey}>
            1
          </VarDeclaration>
        </FunctionDeclaration>
        ;{innerRefkey}
      </>
    );
    expect(() =>
      render(<TestFile>{decl}</TestFile>, { insertFinalNewLine: false }),
    ).toThrow(/Cannot reference a symbol/);
  });

  it("creates symbols for parameters", () => {
    const rk = refkey();

    const decl = (
      <FunctionDeclaration
        name="foo"
        parameters={[{ name: "sym", type: "any", refkey: rk }]}
      >
        <FunctionDeclaration name="bar">{rk}</FunctionDeclaration>
      </FunctionDeclaration>
    );

    expect(<TestFile>{decl}</TestFile>).toRenderTo(`
      function foo(sym: any) {
        function bar() {
          sym
        }
      }
    `);
  });

  it("creates symbols for parameters and addresses conflicts", () => {
    const decl = (
      <FunctionDeclaration
        name="foo"
        parameters={[{ name: "conflict", type: "any" }]}
      >
        <VarDeclaration name="conflict">1</VarDeclaration>;
      </FunctionDeclaration>
    );

    expect(<TestFile>{decl}</TestFile>).toRenderTo(`
      function foo(conflict: any) {
        const conflict_2 = 1;
      }
    `);
  });

  it("create optional parameters", () => {
    const paramDesc: ParameterDescriptor = {
      name: "foo",
      refkey: refkey(),
      type: "any",
      optional: true,
    };
    const decl = (
      <FunctionDeclaration name="foo" parameters={[paramDesc]}>
        console.log(foo);
      </FunctionDeclaration>
    );

    expect(<TestFile>{decl}</TestFile>).toRenderTo(`
      function foo(foo?: any) {
        console.log(foo);
      }
    `);
  });

  it("create optional parameters", () => {
    const paramDesc: ParameterDescriptor = {
      name: "foo",
      refkey: refkey(),
      type: "any[]",
      rest: true,
    };
    const decl = (
      <FunctionDeclaration name="foo" parameters={[paramDesc]}>
        console.log(foo);
      </FunctionDeclaration>
    );

    expect(<TestFile>{decl}</TestFile>).toRenderTo(`
      function foo(...foo: any[]) {
        console.log(foo);
      }
    `);
  });

  it("creates parameters with default values", () => {
    const paramDesc: ParameterDescriptor = {
      name: "foo",
      refkey: refkey(),
      type: "string",
      default: '"bar"',
    };

    const decl = (
      <FunctionDeclaration name="foo" parameters={[paramDesc]}>
        console.log(foo);
      </FunctionDeclaration>
    );

    expect(<TestFile>{decl}</TestFile>).toRenderTo(`
      function foo(foo: string = "bar") {
        console.log(foo);
      }
    `);
  });

  it("correctly renders mixed parameters", () => {
    const params: ParameterDescriptor[] = [
      { name: "a", refkey: refkey(), type: "string" },
      { name: "b", refkey: refkey(), type: "number", optional: true },
      { name: "c", refkey: refkey(), type: "boolean", default: "false" },
      { name: "d", refkey: refkey(), type: "any[]", rest: true },
    ];

    const decl = (
      <FunctionDeclaration name="foo" parameters={params}>
        console.log(a, b, c, d);
      </FunctionDeclaration>
    );

    expect(<TestFile>{decl}</TestFile>).toRenderTo(`
      function foo(a: string, b?: number, c: boolean = false, ...d: any[]) {
        console.log(a, b, c, d);
      }
    `);
  });

  it("adds symbols for members of parameters when a type is provided", () => {
    const ifaceRk = refkey();
    const ifaceMemberRk = refkey();
    const clsRk = refkey();
    const clsMemberRk = refkey();
    const ifaceParamRk = refkey();
    const clsParamRk = refkey();

    const ifaceParam: ParameterDescriptor = {
      name: "ifaceParam",
      refkey: ifaceParamRk,
      type: ifaceRk,
      optional: true,
    };

    const clsParam: ParameterDescriptor = {
      name: "classParam",
      refkey: clsParamRk,
      type: clsRk,
      optional: true,
    };

    const decl = (
      <List doubleHardline>
        <InterfaceDeclaration name="IFace" refkey={ifaceRk}>
          <InterfaceMember name="ifaceProp" refkey={ifaceMemberRk}>
            string
          </InterfaceMember>
        </InterfaceDeclaration>

        <ClassDeclaration name="Class" refkey={clsRk}>
          <ClassField name="classProp" refkey={clsMemberRk}>
            42
          </ClassField>
        </ClassDeclaration>
        <FunctionDeclaration name="fn" parameters={[ifaceParam, clsParam]}>
          <StatementList>
            <>console.log({memberRefkey(ifaceParamRk, ifaceMemberRk)})</>
            <>console.log({memberRefkey(clsParamRk, clsMemberRk)});</>
          </StatementList>
        </FunctionDeclaration>
      </List>
    );

    expect(<TestFile>{decl}</TestFile>).toRenderTo(`
      interface IFace {
        ifaceProp: string
      }

      class Class {
        classProp = 42
      }

      function fn(ifaceParam?: IFace, classParam?: Class) {
        console.log(ifaceParam?.ifaceProp);
        console.log(classParam?.classProp);;
      }
    `);
  });

  it("adds symbols for members of parameters when a type and default are provided", () => {
    const ifaceRk = refkey();
    const ifaceMemberRk = refkey();
    const paramRk = refkey();

    const param: ParameterDescriptor = {
      name: "myParam",
      refkey: paramRk,
      type: ifaceRk,
      default: "undefined",
    };

    const decl = (
      <List doubleHardline>
        <InterfaceDeclaration name="IFace" refkey={ifaceRk}>
          <InterfaceMember name="myProp" refkey={ifaceMemberRk}>
            string
          </InterfaceMember>
        </InterfaceDeclaration>
        <FunctionDeclaration name="fn" parameters={[param]}>
          {memberRefkey(paramRk, ifaceMemberRk)}
        </FunctionDeclaration>
      </List>
    );

    expect(<TestFile>{decl}</TestFile>).toRenderTo(`
      interface IFace {
        myProp: string
      }

      function fn(myParam: IFace = undefined) {
        myParam.myProp
      }
    `);
  });
});

it("has parameters and return type in type ref context", () => {
  const i1 = namekey("iface1");
  const i2 = namekey("iface2");
  const template = (
    <Output>
      <SourceFile path="test1.ts">
        <TypeDeclaration name={i1}>any</TypeDeclaration>
        <hbr />
        <TypeDeclaration name={i2}>any</TypeDeclaration>
      </SourceFile>

      <SourceFile path="test2.ts">
        <FunctionDeclaration
          name="foo"
          parameters={[{ name: "a", type: i1 }]}
          returnType={i2}
        />
      </SourceFile>
    </Output>
  );

  expect(template).toRenderTo({
    "test1.ts": `
      type iface1 = any;
      type iface2 = any;
    `,
    "test2.ts": `
      import type { iface1, iface2 } from "./test1.js";

      function foo(a: iface1): iface2 {}
    `,
  });
});