import type { Children, Namekey, Refkey } from "@alloy-js/core";
import {
  Block,
  computed,
  emitSymbol,
  For,
  isNamekey,
  Match,
  moveTakenMembersTo,
  Switch,
  takeSymbols,
} from "@alloy-js/core";

import { useTSNamePolicy } from "../name-policy.js";
import {
  createStaticMemberSymbol,
  createTransientValueSymbol,
} from "../symbols/index.js";
import { MemberScope } from "./MemberScope.jsx";
import { PropertyName } from "./PropertyName.jsx";
import { ValueExpression } from "./ValueExpression.js";

export interface ObjectExpressionProps {
  children?: Children;
  jsValue?:
    | [string, unknown][]
    | Map<string, unknown>
    | Record<string, unknown>;
}

export function ObjectExpression(props: ObjectExpressionProps) {
  const symbol = createTransientValueSymbol();

  emitSymbol(symbol);
  moveTakenMembersTo(symbol);

  const jsValueProperties = computed(() => {
    const jsValue = props.jsValue;
    let properties: [string, unknown][];
    if (Array.isArray(jsValue)) {
      properties = jsValue;
    } else if (jsValue instanceof Map) {
      properties = [...jsValue.entries()];
    } else if (jsValue !== undefined) {
      properties = Object.entries(jsValue);
    } else {
      properties = [];
    }
    return properties;
  });

  return (
    <Switch>
      <Match
        when={jsValueProperties.value.length === 0 && !("children" in props)}
      >
        {"{}"}
      </Match>
      <Match else>
        <group>
          <MemberScope ownerSymbol={symbol}>
            <Block>
              <For each={jsValueProperties} comma softline enderPunctuation>
                {([name, value]) => (
                  <ObjectProperty name={name} jsValue={value} />
                )}
              </For>
              {props.children && (
                <>
                  {jsValueProperties.value.length > 0 && (
                    <>
                      <sbr />
                    </>
                  )}
                  {props.children}
                </>
              )}
            </Block>
          </MemberScope>
        </group>
      </Match>
    </Switch>
  );
}

export interface ObjectPropertyProps {
  name?: string | Namekey;
  nameExpression?: Children;
  value?: Children;
  jsValue?: unknown;
  children?: Children;
  refkey?: Refkey | Refkey[];
}

export function ObjectProperty(props: ObjectPropertyProps) {
  let sym = undefined;

  if (isNamekey(props.name) || (props.refkey && props.name)) {
    sym = createStaticMemberSymbol(props.name, {
      refkeys: props.refkey,
      namePolicy: useTSNamePolicy().for("object-member-data"),
    });

    moveTakenMembersTo(sym);
    emitSymbol(sym);
  } else {
    // noop
    takeSymbols();
  }

  let name: Children;
  if (sym) {
    name = <PropertyName name={sym.name} />;
  } else if (props.name) {
    // can't be a namekey if we get here
    name = <PropertyName name={props.name as string} />;
  } else if (props.nameExpression) {
    name = <>[{props.nameExpression}]</>;
  } else {
    throw new Error("ObjectProperty either a name or a nameExpression.");
  }

  let value;
  if (props.value) {
    value = props.value;
  } else if (Object.hasOwn(props, "jsValue")) {
    // need the hasOwnProperty check because the value might be falsy.
    value = <ValueExpression jsValue={props.jsValue} />;
  } else if (props.children) {
    value = props.children;
  }

  return (
    <>
      {name}: {value}
    </>
  );
}

export interface ObjectSpreadPropertyProps {
  value?: Children;
  jsValue?: unknown;
  children?: Children;
}

export function ObjectSpreadProperty(props: ObjectSpreadPropertyProps) {
  let value;
  if (props.value) {
    value = props.value;
  } else if (Object.hasOwn(props, "jsValue")) {
    // need the hasOwnProperty check because the value might be falsy.
    value = <ValueExpression jsValue={props.jsValue} />;
  } else if (props.children) {
    value = props.children;
  }

  return <>...{value}</>;
}