/**
 * TOML Printer for Prettier
 * 
 * This module provides a visitor-based printer for TOML CST nodes,
 * converting them to Prettier's document format.
 */

import { BaseTomlCstVisitor } from '@toml-tools/parser';
import { tokensDictionary as t } from '@toml-tools/lexer';
import { doc } from 'prettier';
import type { AstPath, Doc } from 'prettier';
import {
  trimComment,
  collectComments,
  arrItemOffset,
  arrItemProp,
  getSingle,
  formatKey,
  optimizeValue,
} from './printer-utils';
import type { 
  TomlCstNode, 
  TomlDocument, 
  TomlExpression,
  TomlKeyVal,
  TomlComment,
  TomlContext
} from './types';

const { join, line, hardline, softline, ifBreak, indent, group } = doc.builders;

/**
 * TOML Beautifier Visitor class that extends the base CST visitor
 */
class TomlBeautifierVisitor extends BaseTomlCstVisitor {
  // Helper methods
  public mapVisit: (elements: TomlCstNode[] | undefined) => (Doc | string)[];
  public visitSingle: (ctx: TomlContext) => Doc | string;
  public visit: (ctx: TomlCstNode, inParam?: any) => Doc | string;

  constructor() {
    super();
    
    // Try to call validateVisitor if it exists
    if (typeof (this as any).validateVisitor === 'function') {
      (this as any).validateVisitor();
    }
    
    // Initialize helper methods
    this.mapVisit = (elements: TomlCstNode[] | undefined): (Doc | string)[] => {
      if (!elements) {
        return [];
      }
      return elements.map((element) => this.visit(element));
    };

    this.visitSingle = (ctx: TomlContext): Doc | string => {
      const singleElement = getSingle(ctx);
      return this.visit(singleElement);
    };

    // Store reference to inherited visit method and override it
    const originalVisit = Object.getPrototypeOf(this).visit?.bind(this);
    this.visit = (ctx: TomlCstNode, inParam?: any): Doc | string => {
      if (!ctx) {
        return '';
      }
      
      // Try to use the inherited visit method first
      if (originalVisit) {
        try {
          return originalVisit(ctx, inParam);
        } catch (error) {
          console.warn('Original visit method failed:', error);
        }
      }
      
      // Fallback: manually dispatch based on node name/type
      const methodName = ctx.name;
      if (methodName && typeof (this as any)[methodName] === 'function') {
        const visitMethod = (this as any)[methodName];
        try {
          if (ctx.children) {
            return visitMethod.call(this, ctx.children);
          } else {
            return visitMethod.call(this, ctx);
          }
        } catch (error) {
          console.warn(`Visit method ${methodName} failed:`, error);
        }
      }
      
      // Final fallback: return image if available
      return ctx.image || '';
    };
  }

  /**
   * Visit the root TOML document
   */
  toml(ctx: TomlDocument): Doc {
    // Handle empty toml document
    if (!ctx.expression) {
      return [line];
    }

    const isTable = (node: TomlExpression): boolean => {
      return !!node.table;
    };

    const isOnlyComment = (node: TomlExpression): boolean => {
      return !!node.Comment && Object.keys(node).length === 1;
    };

    const expsCsts = ctx.expression;
    const cstGroups: TomlExpression[][] = [];
    let currCstGroup: TomlExpression[] = [];

    // Split expressions into groups defined by tables
    for (let i = expsCsts.length - 1; i >= 0; i--) {
      const currCstNode = expsCsts[i];
      currCstGroup.push(currCstNode);
      
      if (isTable(currCstNode)) {
        let j = i - 1;
        let stillInComments = true;
        
        // Add leading comments to current group
        while (j >= 0 && stillInComments) {
          const priorCstNode = expsCsts[j];
          if (isOnlyComment(priorCstNode)) {
            currCstGroup.push(priorCstNode);
            j--;
            i--;
          } else {
            stillInComments = false;
          }
        }
        
        // Reverse since we scanned backwards
        currCstGroup.reverse();
        cstGroups.push(currCstGroup);
        currCstGroup = [];
      }
    }
    
    if (currCstGroup.length > 0) {
      currCstGroup.reverse();
      cstGroups.push(currCstGroup);
    }

    // Adjust for reverse scanning
    cstGroups.reverse();
    const docGroups = cstGroups.map((currGroup) => this.mapVisit(currGroup));
    
    // Add newlines between group elements
    const docGroupsInnerNewlines = docGroups.map((currGroup) =>
      join(line, currGroup)
    );
    const docGroupsOuterNewlines = join([line, line], docGroupsInnerNewlines);
    
    return [docGroupsOuterNewlines, line];
  }

  /**
   * Visit an expression (keyval, table, or comment)
   */
  expression(ctx: TomlExpression): Doc | string {
    if (ctx.keyval) {
      let keyValDoc = this.visit(ctx.keyval[0]);
      if (ctx.Comment) {
        const commentText = trimComment(ctx.Comment[0].image);
        keyValDoc = [keyValDoc, ' ' + commentText];
      }
      return keyValDoc;
    } else if (ctx.table) {
      let tableDoc = this.visit(ctx.table[0]);
      if (ctx.Comment) {
        const commentText = trimComment(ctx.Comment[0].image);
        tableDoc = [tableDoc, ' ' + commentText];
      }
      return tableDoc;
    } else if (ctx.Comment) {
      return trimComment(ctx.Comment[0].image);
    }
    
    return '';
  }

  /**
   * Visit a key-value pair
   */
  keyval(ctx: TomlKeyVal): Doc {
    const keyDoc = this.visit(ctx.key[0]);
    const valueDoc = this.visit(ctx.val[0]);
    return [keyDoc, ' = ', valueDoc];
  }

  /**
   * Visit a key
   */
  key(ctx: any): Doc {
    const keyTexts = ctx.IKey?.map((tok: any) => {
      const keyText = tok.image;
      // Apply key formatting (add/remove quotes as needed)
      return formatKey(keyText);
    }) || [];
    
    return join('.', keyTexts);
  }

  /**
   * Visit a value
   */
  val(ctx: any): Doc | string {
    try {
      const actualValueNode = getSingle(ctx);
      if (actualValueNode.image !== undefined) {
        // Terminal token - 优化值的表示
        return optimizeValue(actualValueNode.image);
      } else {
        return this.visit(actualValueNode);
      }
    } catch (error) {
      // 如果getSingle失败，尝试直接处理children
      if (ctx.children) {
        // 处理不同类型的值
        for (const [childKey, childNodes] of Object.entries(ctx.children)) {
          if (Array.isArray(childNodes) && childNodes.length > 0) {
            const firstChild = childNodes[0];
            
            // 处理基本类型
            if (firstChild.image !== undefined) {
              // 优化值的表示（特别是字符串）
              return optimizeValue(firstChild.image);
            }
            
            // 处理复杂类型（如数组、内联表等）
            if (firstChild.name) {
              return this.visit(firstChild);
            }
          }
        }
      }
      
      return '';
    }
  }

  /**
   * Visit an array
   */
  array(ctx: any): Doc {
    const arrayValuesDocs = ctx.arrayValues ? this.visit(ctx.arrayValues) : '';
    const postComments = collectComments(ctx.commentNewline);
    const commentsDocs = postComments.map((commentTok) => {
      const trimmedCommentText = trimComment(commentTok.image);
      return [hardline, trimmedCommentText];
    });
    
    return group(['[', indent([arrayValuesDocs, commentsDocs]), softline, ']']);
  }

  /**
   * Visit array values
   */
  arrayValues(ctx: any): Doc {
    const values = ctx.val || [];
    const commas = ctx.Comma || [];
    const comments = collectComments(ctx.commentNewline);

    const itemsCst = [...values, ...commas, ...comments];
    itemsCst.sort((a, b) => {
      const aOffset = arrItemOffset(a);
      const bOffset = arrItemOffset(b);
      return aOffset - bOffset;
    });

    const itemsDoc: Doc[] = [];
    
    for (let i = 0; i < itemsCst.length; i++) {
      const cstItem = itemsCst[i];
      
      if (cstItem.name === 'val') {
        const valDoc = this.visit(cstItem);
        const valEndLine = arrItemProp(cstItem, 'endLine');
        let potentialComma = '';

        // Handle next item (comma or comment)
        if (itemsCst[i + 1]) {
          let nextPossibleComment = itemsCst[i + 1];
          
          // Skip commas
          if (nextPossibleComment.tokenType === t.Comma) {
            potentialComma = ',';
            i++;
            nextPossibleComment = itemsCst[i + 1];
          }
          
          // Handle same-line comments
          if (
            nextPossibleComment &&
            nextPossibleComment.tokenType === t.Comment &&
            nextPossibleComment.startLine === valEndLine
          ) {
            i++;
            const trimmedComment = trimComment(nextPossibleComment.image);
            const comment = ' ' + trimmedComment;
            itemsDoc.push([valDoc, potentialComma, comment, hardline]);
          } else {
            // No comment on same line
            const isTrailingComma = i === itemsCst.length - 1;
            const optionalCommaLineBreak = isTrailingComma
              ? ifBreak(',', '') // Only print trailing comma if multiline array
              : [potentialComma, line];
            itemsDoc.push([valDoc, optionalCommaLineBreak]);
          }
        } else {
          // Last item without followup
          itemsDoc.push([valDoc]);
        }
      } else if (cstItem.tokenType === t.Comment) {
        // Separate line comment
        const trimmedComment = trimComment(cstItem.image);
        itemsDoc.push([trimmedComment, hardline]);
      } else {
        throw new Error('Non-exhaustive match in arrayValues');
      }
    }
    
    return [softline, itemsDoc];
  }

  /**
   * Visit an inline table
   */
  inlineTable(ctx: any): Doc {
    const inlineTableKeyValsDocs = ctx.inlineTableKeyVals
      ? this.visit(ctx.inlineTableKeyVals)
      : '';
    return group(['{ ', inlineTableKeyValsDocs, ' }']);
  }

  /**
   * Visit inline table key-value pairs
   */
  inlineTableKeyVals(ctx: any): Doc {
    const keyValDocs = this.mapVisit(ctx.keyval);
    return join(', ', keyValDocs);
  }

  /**
   * Visit a table
   */
  table(ctx: any): Doc | string {
    return this.visitSingle(ctx);
  }

  /**
   * Visit a standard table
   */
  stdTable(ctx: any): Doc {
    if (ctx.key && ctx.key[0] && ctx.key[0].children && ctx.key[0].children.IKey) {
      const keyTexts = ctx.key[0].children.IKey.map((tok: any) => {
        return formatKey(tok.image);
      });
      return ['[', join('.', keyTexts), ']'];
    }
    return '[]';
  }

  /**
   * Visit an array table
   */
  arrayTable(ctx: any): Doc {
    if (ctx.key && ctx.key[0] && ctx.key[0].children && ctx.key[0].children.IKey) {
      const keyTexts = ctx.key[0].children.IKey.map((tok: any) => {
        return formatKey(tok.image);
      });
      return ['[[', join('.', keyTexts), ']]'];
    }
    return '[[]]';
  }

  /**
   * Visit newline (should not be called)
   */
  nl(ctx: any): never {
    throw new Error('Should not get here!');
  }

  /**
   * Visit comment newline (no-op)
   */
  commentNewline(ctx: any): void {
    // No operation needed
  }
}

// Create singleton visitor instance
const beautifierVisitor = new TomlBeautifierVisitor();

/**
 * Main print function for Prettier
 * @param path - AST path from Prettier
 * @param options - Print options
 * @param print - Print function (unused in this implementation)
 * @returns Formatted document
 */
export function print(path: AstPath<TomlCstNode>, options?: any, print?: any): Doc {
  const cst = path.node as TomlDocument;
  return beautifierVisitor.visit(cst);
}