import { expect } from 'chai';
import { it } from 'mocha';
// @ts-ignore
import babelTraversePkg from '@babel/traverse';
import { swcTraverse } from '../../../src/program/utils/swc-traverse.js';
import { AstService } from '../../../src/program/core/AstService.js';

/**
 * @typedef {import('@swc/core').Module} SwcAstModule
 * @typedef {import('../../../types/index.js').SwcPath} SwcPath
 * @typedef {import('../../../types/index.js').SwcScope} SwcScope
 */

/**
 * @param {SwcAstModule} swcAst
 */
function gatherAllScopes(swcAst) {
  /** @type {SwcScope[]} */
  const swcScopes = [];
  swcTraverse(swcAst, {
    enter({ scope }) {
      if (!swcScopes.includes(scope)) {
        swcScopes.push(scope);
      }
    },
  });
  return swcScopes;
}

describe('swcTraverse', () => {
  describe('Visitor', () => {
    it('traverses an swc AST based on <Node.type> visitor', async () => {
      const code = `import x from 'y';`;
      const swcAst = await AstService._getSwcAst(code);

      let foundImportDeclarationPath;
      const visitor = {
        ImportDeclaration(/** @type {SwcPath} */ path) {
          foundImportDeclarationPath = path;
        },
      };
      swcTraverse(swcAst, visitor);

      expect(foundImportDeclarationPath).to.not.be.undefined;
    });

    it('supports "enter" as a generic arrival handler', async () => {
      const code = `import x from 'y';`;
      const swcAst = await AstService._getSwcAst(code);

      /** @type {string[]} */
      const foundTypes = [];
      const visitor = {
        /**
         * @param {any} path
         */
        enter(path) {
          foundTypes.push(path.node.type);
        },
      };
      swcTraverse(swcAst, visitor);

      expect(foundTypes).to.eql([
        'Module',
        'ImportDeclaration',
        'ImportDefaultSpecifier',
        'Identifier',
        'StringLiteral',
      ]);
    });

    it('supports "enter" and "exit" as generic handlers inside <Node.type> handlers', async () => {
      const code = `import x from 'y';`;
      const swcAst = await AstService._getSwcAst(code);

      /** @type {string[]} */
      const visitedPaths = [];
      const visitor = {
        /**
         * @param {any} path
         */
        ImportDeclaration: {
          enter(path) {
            visitedPaths.push({ path, phase: 'enter' });
          },
          exit(path) {
            visitedPaths.push({ path, phase: 'exit' });
          },
        },
      };
      swcTraverse(swcAst, visitor);

      expect(visitedPaths[0].path).to.equal(visitedPaths[1].path);
      expect(visitedPaths[0].phase).to.equal('enter');
      expect(visitedPaths[1].phase).to.equal('exit');
    });

    it('supports "root" as alternative for Program', async () => {
      const code = `import x from 'y';`;
      const swcAst = await AstService._getSwcAst(code);

      let rootPath;
      const visitor = {
        /**
         * @param {any} path
         */
        root(path) {
          rootPath = path;
        },
      };
      swcTraverse(swcAst, visitor);

      // TODO: also add case for Script
      expect(rootPath.node.type).to.equal('Module');
    });
  });

  describe.skip('Paths', () => {
    it(`adds {
      node: SwcNode;
      parent: SwcNode;
      stop: function;
      scope: SwcScope;
      parentPath: SwcPath;
    }`, async () => {});

    it('supports getPathFromNode', async () => {});
  });

  describe('Scopes', () => {
    describe('Lexical scoping', () => {
      it('creates scopes for blocks', async () => {
        const code = `
        const globalScope = 0;
        {
          const middleScope = 1;
          {
            const deepestScope = 2;
          }  
        }
        const alsoGlobalScope = 3;    
      `;
        const swcAst = await AstService._getSwcAst(code);

        /** @type {SwcPath[]} */
        const declaratorPaths = [];
        const visitor = {
          /**
           * @param {any} path
           */
          VariableDeclarator(path) {
            declaratorPaths.push(path);
          },
        };
        swcTraverse(swcAst, visitor, { needsAdvancedPaths: true });

        expect(declaratorPaths[0].scope.id).to.equal(0);
        expect(declaratorPaths[1].scope.id).to.equal(1);
        expect(declaratorPaths[2].scope.id).to.equal(2);

        expect(declaratorPaths[0].node.id.value).to.equal('globalScope');
        expect(Object.keys(declaratorPaths[0].scope.bindings)).to.eql([
          'globalScope',
          'alsoGlobalScope',
        ]);
        // 0 and 3 are the same scope
        expect(declaratorPaths[0].scope).to.equal(declaratorPaths[3].scope);
        // Scope bindings refer to Declarator nodes
        expect(declaratorPaths[0].scope.bindings.globalScope.identifier).to.equal(
          declaratorPaths[0].node,
        );
        expect(declaratorPaths[0].scope.bindings.alsoGlobalScope.identifier).to.equal(
          declaratorPaths[3].node,
        );

        expect(Object.keys(declaratorPaths[1].scope.bindings)).to.eql(['middleScope']);
        expect(Object.keys(declaratorPaths[2].scope.bindings)).to.eql(['deepestScope']);
      });

      it('creates scopes for nested FunctionDeclaration', async () => {
        const code = `
        function globalFn() {
          function middleScope() {
            function deepestScope() {

            }
          }
        }
      `;
        const swcAst = await AstService._getSwcAst(code);

        /** @type {SwcPath[]} */
        const declaratorPaths = [];
        const visitor = {
          FunctionDeclaration(/** @type {any} */ path) {
            declaratorPaths.push(path);
          },
        };
        swcTraverse(swcAst, visitor, { needsAdvancedPaths: true });
        const scopes = gatherAllScopes(swcAst);

        expect(scopes[1].path?.node).to.equal(declaratorPaths[0].node);
        expect(scopes[2].path?.node).to.equal(declaratorPaths[1].node);
        expect(scopes[3].path?.node).to.equal(declaratorPaths[2].node);
      });

      it('creates scopes for ClassDeclaration', async () => {
        const code = `
        class X extends HTMLElement {
          constructor() {
            var x = 1;
          }

          method() {
            window.alert('hi');
          }
        }
      `;
        const swcAst = await AstService._getSwcAst(code);

        /** @type {SwcPath[]} */
        const declaratorPaths = [];
        const visitor = {
          VariableDeclarator(/** @type {any} */ path) {
            declaratorPaths.push(path);
          },
        };
        swcTraverse(swcAst, visitor, { needsAdvancedPaths: true });

        expect(declaratorPaths[0].scope.id).to.equal(2);
      });

      it('creates scopes SwitchStatement', async () => {
        const code = `
        const myCases = { a: true };
        switch (myCases) {
          case myCases.a:
            const x = 1;
            break;
          default:
        }`;
        const swcAst = await AstService._getSwcAst(code);

        /** @type {SwcPath[]} */
        const declaratorPaths = [];
        const visitor = {
          VariableDeclarator(/** @type {any} */ path) {
            declaratorPaths.push(path);
          },
        };
        swcTraverse(swcAst, visitor, { needsAdvancedPaths: true });

        expect(declaratorPaths[0].node.id.value).to.equal('myCases');
        expect(declaratorPaths[1].node.id.value).to.equal('x');
        expect(declaratorPaths[0].scope.id).to.equal(0);
        expect(declaratorPaths[1].scope.id).to.equal(1);
      });

      it('creates scopes for ObjectExpression', async () => {
        const code = `
        export default {
          toString(dateObj, opt = {}) {},
        };
        `;
        const swcAst = await AstService._getSwcAst(code);

        /** @type {SwcPath[]} */
        const results = [];
        const visitor = {
          MethodProperty(/** @type {any} */ path) {
            results.push(path);
          },
        };
        swcTraverse(swcAst, visitor, { needsAdvancedPaths: true });

        expect(results[0].node.key.value).to.equal('toString');
        expect(results[0].scope.id).to.equal(0);
      });

      it('works for KeyValueProperty', async () => {
        const code = `
        export const x = {
          y:() => {
            const z = 1;
          },
        };
        `;
        const swcAst = await AstService._getSwcAst(code);

        /** @type {SwcPath[]} */
        const declaratorPaths = [];
        const visitor = {
          VariableDeclarator(/** @type {any} */ path) {
            declaratorPaths.push(path);
          },
        };
        swcTraverse(swcAst, visitor, { needsAdvancedPaths: true });

        expect(declaratorPaths[0].node.id.value).to.equal('x');
        expect(declaratorPaths[1].node.id.value).to.equal('z');
        expect(declaratorPaths[0].scope.id).to.equal(0);
        expect(declaratorPaths[1].scope.id).to.equal(1);
      });
    });

    describe('Bindings', () => {
      it('binds const and lets to block scope', async () => {
        const code = `
        const globalScope = 0;
        {
          let middleScope = 1;
          {
            const deepestScope = 2;
          }  
        }
        let alsoGlobalScope = 3;    
      `;
        const swcAst = await AstService._getSwcAst(code);

        /** @type {SwcPath[]} */
        const declaratorPaths = [];
        const visitor = {
          VariableDeclarator(/** @type {SwcPath} */ path) {
            declaratorPaths.push(path);
          },
          FunctionDeclaration(/** @type {SwcPath} */ path) {
            declaratorPaths.push(path);
          },
        };
        swcTraverse(swcAst, visitor, { needsAdvancedPaths: true });

        expect(Object.keys(declaratorPaths[0].scope.bindings)).to.eql([
          'globalScope',
          'alsoGlobalScope',
        ]);
        // Scope bindings refer to Declarator nodes
        expect(declaratorPaths[0].scope.bindings.globalScope.identifier).to.equal(
          declaratorPaths[0].node,
        );
        expect(declaratorPaths[0].scope.bindings.alsoGlobalScope.identifier).to.equal(
          declaratorPaths[3].node,
        );
      });

      it('binds vars to function scope', async () => {
        const code = `
        var globalScope = 0;
        {
          var stillGlobalScope = 1;
          function middleScope() {
            var insideFnScope = 2;
          }  
        }
      `;
        const swcAst = await AstService._getSwcAst(code);

        /** @type {SwcPath[]} */
        const declaratorPaths = [];
        const visitor = {
          VariableDeclarator(/** @type {SwcPath} */ path) {
            declaratorPaths.push(path);
          },
        };
        swcTraverse(swcAst, visitor, { needsAdvancedPaths: true });

        expect(Object.keys(declaratorPaths[0].scope.bindings)).to.eql([
          'globalScope',
          'stillGlobalScope',
        ]);
        expect(Object.keys(declaratorPaths[1].scope.bindings)).to.eql(['middleScope']);
        expect(Object.keys(declaratorPaths[2].scope.bindings)).to.eql(['insideFnScope']);
      });
    });

    describe.skip('References', () => {});
  });

  describe('Babel compatibility', () => {
    const babelTraverse = babelTraversePkg.default;

    /**
     * @param {string} code
     */
    async function compareScopeResultsWithBabel(code) {
      const swcAst = await AstService._getSwcAst(code);
      const babelAst = await AstService._getBabelAst(code);

      /**
       * @type {any[]}
       */
      const babelScopes = [];
      babelTraverse(babelAst, {
        // @ts-ignore
        enter({ scope }) {
          if (!babelScopes.includes(scope)) {
            babelScopes.push(scope);
          }
        },
      });

      /** @type {SwcScope[]} */
      const swcScopes = [];
      swcTraverse(swcAst, {
        enter({ scope }) {
          if (!swcScopes.includes(scope)) {
            swcScopes.push(scope);
          }
        },
      });

      const babelRootScopeIdOffset = babelScopes[0].uid;

      expect(babelScopes.length).to.equal(swcScopes.length);
      for (let i = 0; i < babelScopes.length; i += 1) {
        expect(babelScopes[i].uid - babelRootScopeIdOffset).to.equal(swcScopes[i].id);
        expect(Object.keys(babelScopes[i].bindings)).to.eql(Object.keys(swcScopes[i].bindings));
        // expect(babelScopes[i].references).to.eql(swcResults[i].references);
      }
    }

    it('handles all kinds of lexical scopes and bindings in a similar way', async () => {
      const code = `
      const globalScope = 0;
      function fn() {
        let middleScope = 2;
        function fn() {
          var parentScope = 3;
        }
      }
      const alsoGlobalScope = 4;

      {
        const myCases = { a: true };
        {
          switch (myCases) {
            case myCases.a:
              const x = 1;
              break;
            default:
          };
        }
      }

      class Q {
        constructor() {

        }
      }
    `;

      await compareScopeResultsWithBabel(code);
    });
  });
});