////////////////////////////
// Automatically Generated//
////////////////////////////
use crate::logger::messages::Message;
use crate::parsing::lexer::lex;
use crate::parsing::lexer::lex_tokens::LexToken;
use crate::parsing::parser::parse;
use crate::parsing::parser::parsed_statement::ParsedStatement;
use crate::span::Span;

fn ignore_error(_msg: Message, _: Span) {
}

fn panic_on_error(msg: Message, _: Span) {
    std::panic::panic_any(msg.stringify());
}
#[test]
fn integration_add_function() {
    let script = "int add(int a, int b) {
    return a + b;
}";
    let lexed_tokens = lex(script, &mut panic_on_error);
    println!("Lexed tokens JSON: {}", serde_json::to_string(&lexed_tokens).unwrap());
    let expected_tokens: Vec<LexToken> =
        serde_json::from_str(r#"[
    {
        "token_type": "IntKeyword",
        "span": {
            "start": 0,
            "end": 3
        }
    },
    {
        "token_type": "WhiteSpace",
        "span": {
            "start": 3,
            "end": 4
        }
    },
    {
        "token_type": {
            "Identifier": "add"
        },
        "span": {
            "start": 4,
            "end": 7
        }
    },
    {
        "token_type": "OpenBracket",
        "span": {
            "start": 7,
            "end": 8
        }
    },
    {
        "token_type": "IntKeyword",
        "span": {
            "start": 8,
            "end": 11
        }
    },
    {
        "token_type": "WhiteSpace",
        "span": {
            "start": 11,
            "end": 12
        }
    },
    {
        "token_type": {
            "Identifier": "a"
        },
        "span": {
            "start": 12,
            "end": 13
        }
    },
    {
        "token_type": "Comma",
        "span": {
            "start": 13,
            "end": 14
        }
    },
    {
        "token_type": "WhiteSpace",
        "span": {
            "start": 14,
            "end": 15
        }
    },
    {
        "token_type": "IntKeyword",
        "span": {
            "start": 15,
            "end": 18
        }
    },
    {
        "token_type": "WhiteSpace",
        "span": {
            "start": 18,
            "end": 19
        }
    },
    {
        "token_type": {
            "Identifier": "b"
        },
        "span": {
            "start": 19,
            "end": 20
        }
    },
    {
        "token_type": "CloseBracket",
        "span": {
            "start": 20,
            "end": 21
        }
    },
    {
        "token_type": "WhiteSpace",
        "span": {
            "start": 21,
            "end": 22
        }
    },
    {
        "token_type": "OpenCurlyBracket",
        "span": {
            "start": 22,
            "end": 23
        }
    },
    {
        "token_type": "WhiteSpace",
        "span": {
            "start": 23,
            "end": 24
        }
    },
    {
        "token_type": "WhiteSpace",
        "span": {
            "start": 24,
            "end": 25
        }
    },
    {
        "token_type": "WhiteSpace",
        "span": {
            "start": 25,
            "end": 26
        }
    },
    {
        "token_type": "WhiteSpace",
        "span": {
            "start": 26,
            "end": 27
        }
    },
    {
        "token_type": "WhiteSpace",
        "span": {
            "start": 27,
            "end": 28
        }
    },
    {
        "token_type": "ReturnKeyword",
        "span": {
            "start": 28,
            "end": 34
        }
    },
    {
        "token_type": "WhiteSpace",
        "span": {
            "start": 34,
            "end": 35
        }
    },
    {
        "token_type": {
            "Identifier": "a"
        },
        "span": {
            "start": 35,
            "end": 36
        }
    },
    {
        "token_type": "WhiteSpace",
        "span": {
            "start": 36,
            "end": 37
        }
    },
    {
        "token_type": "Plus",
        "span": {
            "start": 37,
            "end": 38
        }
    },
    {
        "token_type": "WhiteSpace",
        "span": {
            "start": 38,
            "end": 39
        }
    },
    {
        "token_type": {
            "Identifier": "b"
        },
        "span": {
            "start": 39,
            "end": 40
        }
    },
    {
        "token_type": "Semicolon",
        "span": {
            "start": 40,
            "end": 41
        }
    },
    {
        "token_type": "WhiteSpace",
        "span": {
            "start": 41,
            "end": 42
        }
    },
    {
        "token_type": "CloseCurlyBracket",
        "span": {
            "start": 42,
            "end": 43
        }
    },
    {
        "token_type": "EndOfFile",
        "span": {
            "start": 43,
            "end": 43
        }
    }
]"#).unwrap();
    assert_eq!(lexed_tokens, expected_tokens);

    let parsed_tree = parse(lexed_tokens, &mut panic_on_error);
    println!("Parsed Tree JSON: {}", serde_json::to_string(&parsed_tree).unwrap());
    let expected_tree: Box<ParsedStatement> =
        serde_json::from_str(r#"{
  "data": {
    "Script": {
      "statements": [
        {
          "data": {
            "FuncDeclaration": {
              "modifiers": 0,
              "field_mod": null,
              "is_destructor": false,
              "is_constructor": false,
              "returns_reference": false,
              "return_type": {
                "data": {
                  "Type": {
                    "is_const": false,
                    "scope": null,
                    "datatype": {
                      "data": {
                        "DataTypePrimType": {
                          "prim_type": "Int32"
                        }
                      },
                      "span": {
                        "start": 0,
                        "end": 3
                      }
                    },
                    "modifiers": []
                  }
                },
                "span": {
                  "start": 0,
                  "end": 3
                }
              },
              "name": "add",
              "param_list": {
                "data": {
                  "ParamList": {
                    "parameters": [
                      {
                        "parameter_type": {
                          "data": {
                            "Type": {
                              "is_const": false,
                              "scope": null,
                              "datatype": {
                                "data": {
                                  "DataTypePrimType": {
                                    "prim_type": "Int32"
                                  }
                                },
                                "span": {
                                  "start": 8,
                                  "end": 11
                                }
                              },
                              "modifiers": []
                            }
                          },
                          "span": {
                            "start": 8,
                            "end": 11
                          }
                        },
                        "type_mod": null,
                        "identifier": "a",
                        "default": null
                      },
                      {
                        "parameter_type": {
                          "data": {
                            "Type": {
                              "is_const": false,
                              "scope": null,
                              "datatype": {
                                "data": {
                                  "DataTypePrimType": {
                                    "prim_type": "Int32"
                                  }
                                },
                                "span": {
                                  "start": 15,
                                  "end": 18
                                }
                              },
                              "modifiers": []
                            }
                          },
                          "span": {
                            "start": 15,
                            "end": 18
                          }
                        },
                        "type_mod": null,
                        "identifier": "b",
                        "default": null
                      }
                    ]
                  }
                },
                "span": {
                  "start": 7,
                  "end": 21
                }
              },
              "is_const": false,
              "func_attr": 0,
              "block": {
                "data": {
                  "StatBlock": {
                    "statements": [
                      {
                        "data": {
                          "ReturnStatement": {
                            "expression": {
                              "data": {
                                "BinaryExpr": {
                                  "left": {
                                    "data": {
                                      "VarAccess": {
                                        "scope": null,
                                        "identifier": "a"
                                      }
                                    },
                                    "span": {
                                      "start": 35,
                                      "end": 36
                                    }
                                  },
                                  "operator": "Addition",
                                  "right": {
                                    "data": {
                                      "VarAccess": {
                                        "scope": null,
                                        "identifier": "b"
                                      }
                                    },
                                    "span": {
                                      "start": 39,
                                      "end": 40
                                    }
                                  }
                                }
                              },
                              "span": {
                                "start": 35,
                                "end": 40
                              }
                            }
                          }
                        },
                        "span": {
                          "start": 28,
                          "end": 41
                        }
                      }
                    ]
                  }
                },
                "span": {
                  "start": 22,
                  "end": 43
                }
              }
            }
          },
          "span": {
            "start": 0,
            "end": 43
          }
        }
      ]
    }
  },
  "span": {
    "start": 0,
    "end": 43
  }
}
"#).unwrap();
    assert_eq!(parsed_tree, expected_tree);
}
// A substring of a script should never panic, even though it might be completely invalid.
#[test]
fn integration_add_function_substring() {
    let mut script = "int add(int a, int b) {
    return a + b;
}".to_string();
    for _ in 0..script.len() {
        script.pop();
        let lexed_tokens = lex(script.as_str(), &mut ignore_error);
        let _parsed_tree = parse(lexed_tokens, &mut ignore_error);
    }

}