// JavaScript and TypeScript structure checks against the generated printer rules.

import nodes { 노드종류 }
import printer_state { 준비된인쇄상태 }
import printers.javascript.rules { 스칼라뜻검사, 인쇄노드규칙, 인쇄노드규칙읽기, 자식메타필드허용, 자식필드모드 }
import structure { 구조노드, 구조스칼라, 구조입력, 노드스칼라, 스칼라논리, 스칼라문자, 스칼라있음, 스칼라정수 }
import util { 문자열배열에있음 }

function 철자스칼라뜻검사(
  종류: int,
  언어번호: int,
  스칼라: 구조스칼라
) -> Result<bool, string> {
  if 언어번호 != 1 && 언어번호 != 2 {
    return Err("자바스크립트가 아닌 구조에 철자 스칼라가 있습니다")
  }
  let 필드 = 스칼라.필드
  if 필드 == "spelling.singleQuote" {
    if (종류 != 104 && 종류 != 108) || 스칼라.태그 != 2 {
      return Err("작은따옴표 철자 표지가 문자열 리터럴의 참 값이 아닙니다")
    }
    return Ok(true)
  }
  if 필드 == "spelling.escapeBody" {
    if (종류 != 104 && 종류 != 108) || 스칼라.태그 != 5 || 스칼라.문자열값 == "" {
      return Err("탈출 철자 본문이 문자열 리터럴의 문자열 값이 아닙니다")
    }
    let mut 특수철자있음 = false
    for 글자 in 스칼라.문자열값.scalars() {
      let 코드 = 글자.codePointAt(0) ?? 0
      if 글자 == "\\" || 코드 < 32 || 코드 > 126 { 특수철자있음 = true }
    }
    if !특수철자있음 { return Err("탈출 철자 본문에 비정규 철자가 없습니다") }
    return Ok(true)
  }
  if 필드 == "spelling.numericLexeme" {
    if 종류 != 110 || 스칼라.태그 != 5 || 스칼라.문자열값 == "" {
      return Err("숫자 철자 값이 숫자 리터럴의 문자열 값이 아닙니다")
    }
    return Ok(true)
  }
  if 필드 == "spelling.parentheses" {
    if 스칼라.태그 != 3 || 스칼라.정수값 < 1 || 스칼라.정수값 > 262144 {
      return Err("덧괄호 수가 정규 범위의 양의 정수가 아닙니다")
    }
    return Ok(true)
  }
  if 문자열배열에있음([
    "spelling.trailingComma",
    "spelling.omitTrailingComma",
    "spelling.typeMemberComma"
  ], 필드) {
    if 스칼라.태그 != 2 { return Err("구분자 철자 표지가 참 값이 아닙니다") }
    return Ok(true)
  }
  Err("지원하지 않는 철자 스칼라 필드입니다: {필드}")
}

function 방출행사건서명(글: string) -> string {
  let 글자들 = 글.scalars()
  let mut 사건들: Array<string> = []
  let mut 색인 = 0
  while 색인 < 글자들.length {
    if 글자들[색인] == "\r" {
      if 색인 + 1 < 글자들.length && 글자들[색인 + 1] == "\n" {
        사건들.push("crlf")
        색인 = 색인 + 2
      } else {
        사건들.push("cr")
        색인 = 색인 + 1
      }
    } else if 글자들[색인] == "\n" {
      사건들.push("lf")
      색인 = 색인 + 1
    } else {
      let 코드 = 글자들[색인].codePointAt(0) ?? 0
      if 코드 == 8232 { 사건들.push("ls") }
      else if 코드 == 8233 { 사건들.push("ps") }
      색인 = 색인 + 1
    }
  }
  사건들.join(",")
}

function 방출행사건뜻검사(종류: int, 스칼라: 구조스칼라, 노드: 구조노드) -> Result<bool, string> {
  if 스칼라.태그 != 5 || 스칼라.문자열값 == "" {
    return Err("방출 행 사건이 비어 있거나 문자열이 아닙니다")
  }
  let 원시 = if 종류 == 116 { 스칼라문자(노드, "value.raw") }
    else if 종류 == 104 || 종류 == 108 { 스칼라문자(노드, "spelling.escapeBody") }
    else { "" }
  if 원시 == "" || 방출행사건서명(원시) != 스칼라.문자열값 {
    return Err("방출 행 사건이 소유 원시 토큰과 다릅니다")
  }
  Ok(true)
}

export function 철자위치검사(준비: 준비된인쇄상태, 순번: int) -> Result<bool, string> {
  let 노드 = 준비.구조.노드들[순번]
  let 꼬리 = 스칼라논리(노드, "spelling.trailingComma")
  let 꼬리생략 = 스칼라논리(노드, "spelling.omitTrailingComma")
  let 형식쉼표 = 스칼라논리(노드, "spelling.typeMemberComma")
  let 구분자수 = (if 꼬리 { 1 } else { 0 }) +
    (if 꼬리생략 { 1 } else { 0 }) + (if 형식쉼표 { 1 } else { 0 })
  if 구분자수 > 1 { return Err("한 노드에 서로 다른 구분자 철자 표지가 함께 있습니다") }
  if 구분자수 == 0 { return Ok(true) }
  if 노드.부모순번 < 0 || !노드.자식필드있음 {
    return Err("구분자 철자 표지에 부모 역할이 없습니다")
  }
  let 부모종류 = 노드종류(
    준비.언어번호,
    준비.구조.노드들[노드.부모순번].코드워드
  )
  if 형식쉼표 {
    if !((부모종류 == 717 && 노드.자식필드 == "members") ||
      (부모종류 == 720 && 노드.자식필드 == "body")) {
      return Err("형식 멤버 쉼표가 형식 멤버 자리에 있지 않습니다")
    }
    return Ok(true)
  }
  if 노드.자식색인 < 0 { return Err("꼬리 쉼표 표지가 목록 자식에 있지 않습니다") }
  let mut 다음 = 준비.다음형제들[순번]
  while 다음 >= 0 {
    if 준비.구조.노드들[다음].자식필드 == 노드.자식필드 {
      return Err("꼬리 쉼표 표지가 마지막 목록 자식에 있지 않습니다")
    }
    다음 = 준비.다음형제들[다음]
  }
  if 꼬리생략 {
    if 부모종류 != 734 || 노드.자식필드 != "members" {
      return Err("열거형 꼬리 쉼표 생략 표지가 열거형 멤버에 있지 않습니다")
    }
    return Ok(true)
  }
  if !문자열배열에있음([
    "elements", "properties", "arguments", "params", "specifiers", "elementTypes"
  ], 노드.자식필드) {
    return Err("꼬리 쉼표 표지가 허용된 문법 목록에 있지 않습니다")
  }
  Ok(true)
}

function 자식무리검사(
  준비: 준비된인쇄상태,
  부모순번: int,
  종류: int,
  필드: string,
  모드: int
) -> Result<bool, string> {
  let 부모 = 준비.구조.노드들[부모순번]
  let 길이스칼라 = 노드스칼라(부모, "child.{필드}.length")
  let 있음스칼라 = 노드스칼라(부모, "child.{필드}.present")
  let 길이있음 = 길이스칼라.필드 != ""
  let 있음있음 = 있음스칼라.필드 != ""
  if 길이있음 && 있음있음 { return Err("자식 필드 길이와 있음 표지가 함께 있습니다: {필드}") }
  if 길이있음 && (길이스칼라.태그 != 3 || 길이스칼라.정수값 > 262144) {
    return Err("자식 필드 길이가 정규 범위의 음이 아닌 정수가 아닙니다: {필드}")
  }
  if 있음있음 && 있음스칼라.태그 != 1 {
    return Err("없는 자식 필드의 있음 표지가 false가 아닙니다: {필드}")
  }
  let mut 수 = 0
  let mut 이전색인 = -1
  let mut 순번 = 준비.첫자식들[부모순번]
  while 순번 >= 0 {
    let 자식 = 준비.구조.노드들[순번]
    if 자식.자식필드 == 필드 {
      if 모드 <= 2 {
        if 자식.자식색인 != -1 { return Err("단일 자식에 목록 색인이 있습니다: {필드}") }
      } else {
        if 자식.자식색인 < 0 { return Err("목록 자식에 목록 색인이 없습니다: {필드}") }
        let 희소 = (종류 == 201 || 종류 == 202) && 필드 == "elements"
        if 희소 {
          if 자식.자식색인 <= 이전색인 {
            return Err("희소 배열 자식 색인이 오름차순이 아닙니다: {필드}")
          }
        } else if 자식.자식색인 != 수 {
          return Err("목록 자식 색인이 조밀한 순번과 다릅니다: {필드}")
        }
        이전색인 = 자식.자식색인
      }
      수 = 수 + 1
    }
    순번 = 준비.다음형제들[순번]
  }
  if 모드 == 1 {
    if 수 != 1 || 길이있음 || 있음있음 { return Err("필수 단일 자식이 정규형이 아닙니다: {필드}") }
  } else if 모드 == 2 {
    if 수 > 1 || 길이있음 || (수 == 0 && !있음있음) || (수 == 1 && 있음있음) {
      return Err("선택 단일 자식이 정규형이 아닙니다: {필드}")
    }
  } else {
    if 모드 == 3 && (!길이있음 || 있음있음) {
      return Err("필수 목록 자식의 길이 표지가 정규형이 아닙니다: {필드}")
    }
    if 모드 == 4 && ((!길이있음 && !있음있음) || (길이있음 && 있음있음)) {
      return Err("선택 목록 자식의 메타 표지가 정규형이 아닙니다: {필드}")
    }
    if 있음있음 && 수 != 0 { return Err("없다고 표시한 목록에 자식이 있습니다: {필드}") }
    if 길이있음 {
      let 길이 = 길이스칼라.정수값
      let 희소 = (종류 == 201 || 종류 == 202) && 필드 == "elements"
      if (!희소 && 수 != 길이) || (희소 && 이전색인 >= 길이) {
        return Err("목록 자식 수 또는 색인이 선언 길이와 다릅니다: {필드}")
      }
    }
  }
  Ok(true)
}

export function 노드자식스키마검사(준비: 준비된인쇄상태, 부모순번: int) -> Result<bool, string> {
  let 부모 = 준비.구조.노드들[부모순번]
  let 종류 = 노드종류(준비.언어번호, 부모.코드워드)
  let 규칙 = 인쇄노드규칙읽기(준비.언어번호, 종류)
  for 스칼라 in 부모.스칼라들 {
    if 스칼라.필드.startsWith("child.") {
      if !자식메타필드허용(
        규칙.선택단일,
        규칙.필수목록,
        규칙.선택목록,
        스칼라.필드
      ) {
        return Err("노드 종류에 허용되지 않은 자식 메타 필드입니다: {스칼라.필드}")
      }
    } else if 스칼라.필드.startsWith("spelling.") {
      철자스칼라뜻검사(종류, 준비.언어번호, 스칼라)?
    } else if 스칼라.필드 == "emission.rawRowEvents" &&
      (준비.언어번호 == 1 || 준비.언어번호 == 2) {
      방출행사건뜻검사(종류, 스칼라, 부모)?
    } else if 스칼라.필드 == "emission.imageOnlyLeadingLineCommentRows" {
      if 준비.언어번호 != 2 || 스칼라.태그 != 3 ||
        스칼라.정수값 < 1 || 스칼라.정수값 > 262144 {
        return Err("영상 전용 줄댓글 행수가 정규 양의 정수가 아닙니다")
      }
      if 부모.부모순번 < 0 || !부모.자식필드있음 {
        return Err("영상 전용 줄댓글 행수에 문장 목록 자리가 없습니다")
      }
      let 목록종류 = 노드종류(
        준비.언어번호,
        준비.구조.노드들[부모.부모순번].코드워드
      )
      if !((부모.자식필드 == "body" &&
          (목록종류 == 102 || 목록종류 == 410 || 목록종류 == 603 ||
            목록종류 == 609 || 목록종류 == 731)) ||
        (부모.자식필드 == "consequent" && 목록종류 == 511)) {
        return Err("영상 전용 줄댓글 행수가 문장 목록 밖에 있습니다")
      }
    } else if (준비.언어번호 == 1 || 준비.언어번호 == 2) &&
      문자열배열에있음(["startRow", "startColumn", "endRow", "endColumn"], 스칼라.필드) {
      if 스칼라.태그 != 3 || 스칼라.정수값 < 0 {
        return Err("JS/TS 행 기하 스칼라가 음이 아닌 정수가 아닙니다: {스칼라.필드}")
      }
    } else {
      if !문자열배열에있음(규칙.허용스칼라, 스칼라.필드) {
        return Err("노드 종류에 허용되지 않은 구조 스칼라 필드입니다: {스칼라.필드}")
      }
      스칼라뜻검사(종류, 준비.언어번호, 스칼라)?
    }
  }
  for 필드 in 규칙.필수스칼라 {
    if !스칼라있음(부모, 필드) {
      return Err("노드 종류의 필수 구조 스칼라가 없습니다: {필드}")
    }
  }
  if 종류 == 106 || 종류 == 714 {
    if 부모.식별자있음 {
      if 스칼라있음(부모, "name") {
        return Err("식별자 이름이 이미지와 분리 본문에 함께 있습니다")
      }
    } else if !스칼라있음(부모, "name") {
      return Err("이미지에 남은 식별자 이름 스칼라가 없습니다")
    }
  } else if 부모.식별자있음 {
    return Err("식별자가 아닌 노드에 식별자 분리 본문이 있습니다")
  }
  let mut 자식순번값 = 준비.첫자식들[부모순번]
  while 자식순번값 >= 0 {
    let 자식 = 준비.구조.노드들[자식순번값]
    let 모드 = 자식필드모드(
      규칙.필수단일,
      규칙.선택단일,
      규칙.필수목록,
      규칙.선택목록,
      자식.자식필드
    )
    if 모드 == 0 {
      return Err("노드 종류에 허용되지 않은 자식 필드입니다: {자식.자식필드}")
    }
    자식순번값 = 준비.다음형제들[자식순번값]
  }
  for 필드 in 규칙.필수단일 { 자식무리검사(준비, 부모순번, 종류, 필드, 1)? }
  for 필드 in 규칙.선택단일 { 자식무리검사(준비, 부모순번, 종류, 필드, 2)? }
  for 필드 in 규칙.필수목록 { 자식무리검사(준비, 부모순번, 종류, 필드, 3)? }
  for 필드 in 규칙.선택목록 { 자식무리검사(준비, 부모순번, 종류, 필드, 4)? }
  Ok(true)
}

export function 타입스크립트영상댓글행계획검사(구조: 구조입력) -> Result<bool, string> {
  let mut 문장들: Array<int> = []
  let mut 댓글들: Array<int> = []
  let mut 기대행들: Array<int> = []
  let mut 순번 = 0
  let mut 이전문장시작 = -1
  let mut 이전댓글끝 = -1
  while 순번 < 구조.노드들.length {
    기대행들.push(0)
    let 노드 = 구조.노드들[순번]
    if 노드.부모순번 >= 0 && 노드.자식필드있음 {
      let 부모종류 = 노드종류(2, 구조.노드들[노드.부모순번].코드워드)
      let 문장자리 =
        (노드.자식필드 == "body" &&
          (부모종류 == 102 || 부모종류 == 410 || 부모종류 == 603 ||
            부모종류 == 609 || 부모종류 == 731)) ||
        (노드.자식필드 == "consequent" && 부모종류 == 511)
      if 문장자리 {
        if 노드.시작 < 이전문장시작 {
          return Err("영상 전용 줄댓글 문장들이 원본 차례가 아닙니다")
        }
        문장들.push(순번)
        이전문장시작 = 노드.시작
      }
    }
    if 노드종류(2, 노드.코드워드) == 120 {
      if 노드.끝 < 이전댓글끝 {
        return Err("영상 전용 줄댓글들이 원본 차례가 아닙니다")
      }
      댓글들.push(순번)
      이전댓글끝 = 노드.끝
    }
    순번 = 순번 + 1
  }
  let mut 문장색인 = 0
  for 댓글순번 in 댓글들 {
    let 댓글 = 구조.노드들[댓글순번]
    while 문장색인 < 문장들.length &&
      구조.노드들[문장들[문장색인]].시작 < 댓글.끝 {
      문장색인 = 문장색인 + 1
    }
    if 문장색인 < 문장들.length {
      let 문장순번 = 문장들[문장색인]
      기대행들[문장순번] = 기대행들[문장순번] + 1
    }
  }
  순번 = 0
  while 순번 < 구조.노드들.length {
    let 노드 = 구조.노드들[순번]
    let 실제 = 스칼라정수(노드, "emission.imageOnlyLeadingLineCommentRows")
    if 실제 != 기대행들[순번] {
      return Err("영상 전용 줄댓글 행수가 원본 기하와 다릅니다: 순번 {순번}")
    }
    순번 = 순번 + 1
  }
  Ok(true)
}
