import type {Dependencies, Signature} from '../interfaces/type.js'
import {$$typeToString, $$ts, $$define, $$raw, $$ident, $$escape} from 'ts-macros'
import * as ts from 'typescript'

export const square =
   <T>(dep: Dependencies<'multiply', T>): Signature<'square', T> =>
   z => dep.multiply(z, z)
   // z => dep.fooBar(z, z) // fails as desired
   // z => dep.multiply(z, 'foo') // still fails as desired

// make sure ts-macros is running
function $contains<T>(value: T, ...possible: Array<T>) {
    // repetition which goes over all the elements in the "possible" array
    return +["||", [possible], (item: T) => value === item];
}

const searchItem = "needle";
console.log("In generic arithmetic")
console.log($contains!(searchItem, "erwin", "tj")); 
// Transpiles to: console.log(false);

// OK, record the type of square:
square.reflectedType = //$$typeToString!<typeof square>();
   $$typeToString!<
      <T>(...args: DeepExpand<Parameters<typeof square<T>>>)
         => DeepExpand<ReturnType<typeof square<T>>>
   >()

type ShallowExpand<T> =  T extends unknown ? { [K in keyof T]: T[K] } : never;
// Short alias of ShallowExpand for convenience below:
type Deps<T> =  T extends unknown ? { [K in keyof T]: T[K] } : never;
type ExpandedParameters<T extends (...args: any) => any> = {[Index in keyof Parameters<T>]: ShallowExpand<Parameters<T>[Index]>}
type ExpandTwice<T extends any[]> = {[Index in keyof T] : ShallowExpand<T[Index]>}
type AsArray<T> = T extends any[] ? T : [];
type DeepExpand<T> =
   T extends (...args: any) => any
      ? (...pars: AsArray<DeepExpand<Parameters<T>>>) => DeepExpand<ReturnType<T>> :
   T extends unknown ? { [K in keyof T]: DeepExpand<T[K]> } : never;

type Out<T> = ShallowExpand<Dependencies<'multiply', T>>;

console.log("Deps type is", $$typeToString!<<T>() => Out<T>>())

type OutB = ExpandTwice<Parameters<typeof square>>;

console.log("Or perhaps", $$typeToString!<OutB>())

console.log("Or maybe even", $$typeToString!<
            <T>(...args: DeepExpand<Parameters<typeof square<T>>>) => DeepExpand<ReturnType<typeof square<T>>>
            >())

// Now try to wrap it up in a macro

// From the creator of ts-macros; temporary until next release
function $export(name: string, value: unknown) {
   $$raw!((ctx, name: ts.Expression, value: ts.Expression) => {
      if (!ctx.ts.isStringLiteral(name)) throw ctx.error(name, "Expected a string literal.");
       return [ctx.factory.createVariableStatement([ctx.factory.createToken(ctx.ts.SyntaxKind.ExportKeyword)], ctx.factory.createVariableDeclarationList([
         ctx.factory.createVariableDeclaration(name.text, undefined, undefined, value)
     ], ctx.ts.NodeFlags.Const))];
   });
}

// Obviously we'd prefer the name before the expression, but that won't work
// until the next release
function $exportImpl<Impl>(expr: Impl, name: string) {
   $export!(name, expr);
   $$ident!(name).reflectedType = $$typeToString!<
      //      <T>(...args: DeepExpand<Parameters<Impl<T>>>) => DeepExpand<ReturnType<Impl<T>>> // see comment in reflect below.
      Impl
      >();
}

// works but then not visible at import with current ts-macros.
// Author says he will be enhancing this "soon."
$exportImpl!(<T>(dep: Dependencies<'multiply', T>): Signature<'square', T> =>
                z => dep.multiply(z, z),
             'squire')

function $reflect<Impl>(expr: Impl) {
   return $$escape!(() => {
      const temp: Impl & {reflectedType?: string} = expr;
      temp.reflectedType =  $$typeToString!<
         // <T>(...args: DeepExpand<Parameters<Impl<T>>>) =>
         // DeepExpand<ReturnType<Impl<T>>> // error; can't instantiate
         // Impl; even if we constrain it to be the type of a generic function,
         // that's still not a generic _type_, ugh.
         Impl>();
      return temp;
   }) as Impl & {reflectedType: string}
}

export const squre = $reflect!(
      <T>(dep: Dependencies<'multiply', T>): Signature<'square', T> =>
      z => dep.multiply(z, z))

export const sqre = $reflect!(
      <T>(dep: Deps<Dependencies<'multiply', T>>): Signature<'square', T> =>
      z => dep.multiply(z, z))