# pyright: reportInvalidTypeForm=false
from __future__ import annotations

import os
import re
import io
import enum
import math
import tqdm
import argparse
import pydantic
import subprocess

from ctypes import c_uint16, c_int16, c_uint64, c_uint32, c_int32, c_uint8, c_float, sizeof as c_sizeof
from typing import Protocol, BinaryIO, Type, Iterable, cast
from pathlib import Path

from cstruct import CStructure, ctypes_types, CTypeType, c_addr_ptr, c_str, print_carr


def vram2offset(vram: int):
    return vram - 0xFF000


sceVu0FVECTOR = c_float * 4
sceVu0IVECTOR = c_int32 * 4
sceVu0FMATRIX = sceVu0FVECTOR * 4

qword = c_int32 * 4


class ANI_CODE(c_uint16):
    def __str__(self):
        return f"{self.value}"


class GS_REG(c_uint64):
    def __str__(self):
        return f"0x{self.value:x}"


class HEX_ADDR(c_uint32):
    def __str__(self):
        return f"0x{self.value:x}"


# CTypeTypeEX = CTypeType | type[sceVu0FVECTOR] | type[sceVu0IVECTOR]


# struct SPRT_DAT { // size:0x20
#     u_long tex0;
#     u_short u;
#     u_short v;
#     u_short w;
#     u_short h;
#     int x;
#     int y;
#     int pri;
#     u_char alpha;
# };
class SPRT_DAT(CStructure):
    tex0: GS_REG
    u: c_uint16
    v: c_uint16
    w: c_uint16
    h: c_uint16
    x: c_int32
    y: c_int32
    pri: c_int32
    alpha: c_uint8


# typedef struct { // 0x8
#     int file_no;
#     u_short vol;
# } ADPCM_VOL;
class ADPCM_VOL(CStructure):
    file_no: c_int32
    vol: c_uint16


# typedef struct { // 0x4
#     u_short se_no0;
#     u_short se_no1;
# } SE_STE;
class SE_STE(CStructure):
    se_no0: c_uint16
    se_no1: c_uint16


# typedef struct { // 0x8
#     int file_no;
#     u_char fg_no;
# } FG_FILE_TBL;
class FG_FILE_TBL(CStructure):
    file_no: c_int32
    fg_no: c_uint8


# typedef struct {
# 	int file_no;
# 	u_short vol;
# } ADPCM_ROOM_PLAY;
class ADPCM_ROOM_PLAY(CStructure):
    file_no: c_int32
    vol: c_uint16


# typedef struct {
# 	u_short rvol;
# 	u_char door_no;
# 	u_char foot_no;
# 	u_char srund_no;
# 	u_char event_no;
# 	u_char adpcm[5];
# } ROOM_SOUND_INFO;
class ROOM_SOUND_INFO(CStructure):
    rvol: c_uint16
    door_no: c_uint8
    foot_no: c_uint8
    srund_no: c_uint8
    event_no: c_uint8
    adpcm: c_uint8 * 5


# typedef struct {
#   u_int fno[3];
# } ROOM_DOOR_SE;
class ROOM_DOOR_SE(CStructure):
    fno: c_uint32 * 3


# typedef struct {
#   u_int fno[5];
# } ROOM_FOOT_SE;
class ROOM_FOOT_SE(CStructure):
    fno: c_uint32 * 5


# typedef struct {
#   u_char num;
#   u_char rate[4];
# } SE_FOOT_RAND_ITA;
class SE_FOOT_RAND_ITA(CStructure):
    num: c_uint8
    rate: c_uint8 * 4


# typedef struct { // 0x40
# 	/* 0x00 */ sceVu0FVECTOR fall_speed;
# 	/* 0x10 */ sceVu0IVECTOR wind;
# 	/* 0x20 */ sceVu0FVECTOR rotate;
# 	/* 0x30 */ int stop_time;
# 	/* 0x34 */ short int r;
# 	/* 0x36 */ short int g;
# 	/* 0x38 */ short int b;
# 	/* 0x3a */ short int a;
# } FALL_TABLE;
class FALL_TABLE(CStructure, align=64):
    fall_speed: sceVu0FVECTOR
    wind: sceVu0IVECTOR
    rotate: sceVu0FVECTOR
    stop_time: c_int32
    r: c_int16
    g: c_int16
    b: c_int16
    a: c_int16


# typedef struct { // 0xe
# 	/* 0x0 */ short int u;
# 	/* 0x2 */ short int v;
# 	/* 0x4 */ short int w;
# 	/* 0x6 */ short int h;
# 	/* 0x8 */ short int x;
# 	/* 0xa */ short int y;
# 	/* 0xc */ u_char pri;
# 	/* 0xd */ u_char alp;
# } SPRT_SDAT;
class SPRT_SDAT(CStructure):
    u: c_int16
    v: c_int16
    w: c_int16
    h: c_int16
    x: c_int16
    y: c_int16
    pri: c_uint8
    alp: c_uint8


# typedef struct { // 0x8
# 	/* 0x0 */ short int cx;
# 	/* 0x2 */ short int cy;
# 	/* 0x4 */ float rot;
# } SPRT_SROT;
class SPRT_SROT(CStructure):
    cx: c_int16
    cy: c_int16
    rot: c_float


# typedef struct { // 0x8
# 	/* 0x0 */ short int cx;
# 	/* 0x2 */ short int cy;
# 	/* 0x4 */ short int sw;
# 	/* 0x6 */ short int sh;
# } SPRT_SSCL;
class SPRT_SSCL(CStructure):
    cx: c_int16
    cy: c_int16
    sw: c_int16
    sh: c_int16


# typedef struct { // 0x14
#     /* 0x00 */ short int x_trans;
#     /* 0x02 */ short int y_trans;
#     /* 0x04 */ short int x_scale;
#     /* 0x06 */ short int y_scale;
#     /* 0x08 */ short int rotation;
#     /* 0x0a */ short int alpha;
#     /* 0x0c */ short int counter;
#     /* 0x10 */ u_int attribute;
# } ANM2D_DAT_TABLE;
class ANM2D_DAT_TABLE(CStructure):
    x_trans: c_int16
    y_trans: c_int16
    x_scale: c_int16
    y_scale: c_int16
    rotation: c_int16
    alpha: c_int16
    counter: c_int16
    attribute: c_uint32


# typedef struct { // 0x110
#     /* 0x000 */ int anm_index;
#     /* 0x004 */ SPRT_SDAT *sdat_p;
#     /* 0x008 */ SPRT_SDAT sdat[8];
#     /* 0x078 */ SPRT_SROT srot[8];
#     /* 0x0b8 */ SPRT_SSCL sscl[8];
#     /* 0x0f8 */ int sp_no;
#     /* 0x0fc */ void *table_p;
#     /* 0x100 */ short int x_speed;
#     /* 0x102 */ short int y_speed;
#     /* 0x104 */ short int xscal_off;
#     /* 0x106 */ short int yscal_off;
#     /* 0x108 */ short int rot_off;
#     /* 0x10a */ short int alpha_off;
#     /* 0x10c */ short int counter;
#     /* 0x10e */ short int pad;
# } ANM2D_WRK_TABLE;
class ANM2D_WRK_TABLE(CStructure):
    anm_index: c_int32
    sdat_p: c_addr_ptr  # SPRT_SDAT
    sdat: SPRT_SDAT * 8
    srot: SPRT_SROT * 8
    sscl: SPRT_SSCL * 8
    sp_no: c_int32
    table_p: c_addr_ptr
    x_speed: c_int16
    y_speed: c_int16
    xscal_off: c_int16
    yscal_off: c_int16
    rot_off: c_int16
    alpha_off: c_int16
    counter: c_int16
    pad: c_int16


# typedef struct { // 0x17b0
# 	/* 0x0000 */ sceVu0FVECTOR mpos_keep;
# 	/* 0x0010 */ void *pos_p;
# 	/* 0x0014 */ short int at_ground[600];
# 	/* 0x04c4 */ short int rgba[600][4];
# 	/* 0x1784 */ int fnum_keep;
# 	/* 0x1788 */ int fall_count;
# 	/* 0x178c */ float fall_rate;
# 	/* 0x1790 */ float rate_remain;
# 	/* 0x1794 */ short int mode_keep;
# 	/* 0x1796 */ short int area_keep;
# 	/* 0x1798 */ short int dist;
# 	/* 0x179a */ short int init_flg;
# 	/* 0x179c */ short int offs[3];
# } LEAVES_TABLE;
class LEAVES_TABLE(CStructure):
    mpos_keep: sceVu0FVECTOR
    pos_p: c_addr_ptr
    at_ground: c_int16 * 600
    rgba: c_int16 * 4 * 600
    fnum_keep: c_int32
    fall_count: c_int32
    fall_rate: c_float
    rate_remain: c_float
    mode_keep: c_int16
    area_keep: c_int16
    dist: c_int16
    init_flg: c_int16
    offs: c_int16 * 3


# typedef struct { // 0x10
# 	/* 0x0 */ u_long tex_keep;
# 	/* 0x8 */ short int tm2_id;
# 	/* 0xa */ short int mode;
# 	/* 0xc */ short int load_id;
# 	/* 0xe */ short int pad;
# } BTL_ANM_LOAD;
class BTL_ANM_LOAD(CStructure):
    tex_keep: c_uint64
    tm2_id: c_int16
    mode: c_int16
    load_id: c_int16
    pad: c_int16


# typedef struct { // 0x60
# 	/* 0x00 */ sceGsTex0 g_GsTex0;
# 	/* 0x08 */ u_int g_nTexSizeW;
# 	/* 0x0c */ u_int g_nTexSizeH;
# 	/* 0x10 */ u_char g_bMipmapLv;
# 	/* 0x18 */ long unsigned int g_GsMiptbp1;
# 	/* 0x20 */ long unsigned int g_GsMiptbp2;
# 	/* 0x28 */ float pos_x;
# 	/* 0x2c */ float pos_y;
# 	/* 0x30 */ int pos_z;
# 	/* 0x34 */ float size_w;
# 	/* 0x38 */ float size_h;
# 	/* 0x3c */ float scale_w;
# 	/* 0x40 */ float scale_h;
# 	/* 0x44 */ int clamp_u;
# 	/* 0x48 */ int clamp_v;
# 	/* 0x4c */ u_int rot_center;
# 	/* 0x50 */ float angle;
# 	/* 0x54 */ u_char r;
# 	/* 0x55 */ u_char g;
# 	/* 0x56 */ u_char b;
# 	/* 0x57 */ u_char alpha;
# 	/* 0x58 */ u_int mask;
# } SPRITE_DATA;
class SPRITE_DATA(CStructure):
    g_GsTex0: c_uint64  # sceGsTex0
    g_nTexSizeW: c_uint32
    g_nTexSizeH: c_uint32
    g_bMipmapLv: c_uint8
    g_GsMiptbp1: c_uint64
    g_GsMiptbp2: c_uint64
    pos_x: c_float
    pos_y: c_float
    pos_z: c_int32
    size_w: c_float
    size_h: c_float
    scale_w: c_float
    scale_h: c_float
    clamp_u: c_int32
    clamp_v: c_int32
    rot_center: c_uint32
    angle: c_float
    r: c_uint8
    g: c_uint8
    b: c_uint8
    alpha: c_uint8
    mask: c_uint32


# typedef struct { // 0x30
# 	/* 0x00 */ u_long tex1;
# 	/* 0x08 */ u_long alpha;
# 	/* 0x10 */ u_long zbuf;
# 	/* 0x18 */ u_long test;
# 	/* 0x20 */ u_long clamp;
# 	/* 0x28 */ u_long prim;
# } DRAW_ENV;
class DRAW_ENV(CStructure):
    tex1: c_uint64
    alpha: c_uint64
    zbuf: c_uint64
    test: c_uint64
    clamp: c_uint64
    prim: c_uint64


###########################################################################


# typedef struct { // 0x14
# 	/* 0x00 */ u_char sw;
# 	/* 0x01 */ u_char alp;
# 	/* 0x04 */ int scl;
# 	/* 0x08 */ int rot;
# 	/* 0x0c */ float x;
# 	/* 0x10 */ float y;
# } BLUR_STR;
class BLUR_STR(CStructure):
    sw: c_uint8
    alp: c_uint8
    scl: c_int32
    rot: c_int32
    x: c_float
    y: c_float


# typedef struct { // 0x4
# 	/* 0x0 */ u_char sw;
# 	/* 0x1 */ u_char type;
# 	/* 0x2 */ u_char col;
# 	/* 0x3 */ u_char alp;
# } CONTRAST_STR;
class CONTRAST_STR(CStructure):
    sw: c_uint8
    type: c_uint8
    col: c_uint8
    alp: c_uint8


# typedef struct { // 0x2
# 	/* 0x0 */ u_char sw;
# 	/* 0x1 */ u_char alp;
# } FFRAME_STR;
class FFRAME_STR(CStructure):
    sw: c_uint8
    alp: c_uint8


# typedef struct { // 0x10
# 	/* 0x0 */ u_char sw;
# 	/* 0x1 */ u_char type;
# 	/* 0x4 */ float spd;
# 	/* 0x8 */ float alp;
# 	/* 0xc */ u_char amax;
# 	/* 0xd */ u_char cmax;
# } DITHER_STR;
class DITHER_STR(CStructure):
    sw: c_uint8
    type: c_uint8
    spd: c_float
    alp: c_float
    amax: c_uint8
    cmax: c_uint8


# typedef struct { // 0x3
# 	/* 0x0 */ u_char sw;
# 	/* 0x1 */ u_char type;
# 	/* 0x2 */ u_char rate;
# } DEFORM_STR;
class DEFORM_STR(CStructure):
    sw: c_uint8
    type: c_uint8
    rate: c_uint8


# typedef struct { // 0x4
# 	/* 0x0 */ u_char sw;
# 	/* 0x1 */ u_char col;
# 	/* 0x2 */ u_char alp;
# 	/* 0x3 */ u_char alp2;
# } NEGA_STR;
class NEGA_STR(CStructure):
    sw: c_uint8
    col: c_uint8
    alp: c_uint8
    alp2: c_uint8


# typedef struct { // 0x1
# 	/* 0x0 */ u_char sw;
# } MONO_STR;
class MONO_STR(CStructure):
    sw: c_uint8


# typedef struct { // 0x34
# 	/* 0x00 */ BLUR_STR bl;
# 	/* 0x14 */ CONTRAST_STR cn;
# 	/* 0x18 */ FFRAME_STR ff;
# 	/* 0x1c */ DITHER_STR dt;
# 	/* 0x2c */ DEFORM_STR df;
# 	/* 0x2f */ NEGA_STR ng;
# 	/* 0x33 */ MONO_STR mn;
# } SBTSET;
class SBTSET(CStructure):
    bl: BLUR_STR
    cn: CONTRAST_STR
    ff: FFRAME_STR
    dt: DITHER_STR
    df: DEFORM_STR
    ng: NEGA_STR
    mn: MONO_STR


# typedef struct { // 0x28
# 	/* 0x00 */ u_int flow;
# 	/* 0x04 */ u_int cnt;
# 	/* 0x08 */ u_int in;
# 	/* 0x0c */ u_int keep;
# 	/* 0x10 */ u_int out;
# 	/* 0x14 */ u_int alp;
# 	/* 0x18 */ float scl;
# 	/* 0x1c */ float rot;
# 	/* 0x20 */ float cx;
# 	/* 0x24 */ float cy;
# } EFF_BLUR;
class EFF_BLUR(CStructure):
    flow: c_uint32
    cnt: c_uint32
    _in: c_uint32
    keep: c_uint32
    out: c_uint32
    alp: c_uint32
    scl: c_float
    rot: c_float
    cx: c_float
    cy: c_float


# typedef struct { // 0x18
# 	/* 0x00 */ u_int flow;
# 	/* 0x04 */ u_int cnt;
# 	/* 0x08 */ u_int in;
# 	/* 0x0c */ u_int keep;
# 	/* 0x10 */ u_int out;
# 	/* 0x14 */ u_int max;
# } EFF_FOCUS;
class EFF_FOCUS(CStructure):
    flow: c_uint32
    cnt: c_uint32
    _in: c_uint32
    keep: c_uint32
    out: c_uint32
    max: c_uint32


# typedef struct { // 0x4
# 	/* 0x0 */ u_char type;
# 	/* 0x1 */ u_char otype;
# 	/* 0x2 */ u_char init;
# 	/* 0x3 */ u_char pass;
# } EFF_DEFORM;
class EFF_DEFORM(CStructure):
    type: c_uint8
    otype: c_uint8
    init: c_uint8
    _pass: c_uint8


###########################################################################


# typedef struct { // 0x10
# 	/* 0x0 */ int mesno;
# 	/* 0x4 */ u_int in;
# 	/* 0x8 */ u_int out;
# 	/* 0xc */ u_int attr;
# } SUBTITLES;
class SUBTITLES(CStructure):
    mesno: c_int32
    _in: c_uint32
    out: c_uint32
    attr: c_uint32


# typedef struct { // 0x20
# 	/* 0x00 */ int pos_x;
# 	/* 0x04 */ int pos_y;
# 	/* 0x08 */ int path;
# 	/* 0x0c */ int fr_rate;
# 	/* 0x10 */ int pri;
# 	/* 0x14 */ u_int attr;
# 	/* 0x18 */ int *tbl;
# 	/* 0x1c */ SUBTITLES **list;
# } SUBTITLES_DAT;
class SUBTITLES_DAT(CStructure):
    pos_x: c_int32
    pos_y: c_int32
    path: c_int32
    fr_rate: c_int32
    pri: c_int32
    attr: c_uint32
    tbl: c_addr_ptr
    list: c_addr_ptr


# typedef struct { // 0x10
# 	/* 0x0 */ u_int type;
# 	/* 0x4 */ u_int no;
# 	/* 0x8 */ u_int cnt;
# 	/* 0xc */ u_char alp;
# 	/* 0xd */ u_char flg;
# 	/* 0xe */ u_char run;
# 	/* 0xf */ u_char dummy;
# } SUBTITLES_SYS;
class SUBTITLES_SYS(CStructure):
    type: c_uint32
    no: c_uint32
    cnt: c_uint32
    alp: c_uint8
    flg: c_uint8
    run: c_uint8
    dummy: c_uint8


###########################################################################
# typedef struct
# { // 0xc
#     /* 0x0 */ char *name;
#     /* 0x4 */ int subnum;
#     /* 0x8 */ int nmax;
# } DEBUG_SUB_MENU;
class DEBUG_SUB_MENU(CStructure, pack=1):
    name: c_str
    subnum: c_int32
    nmax: c_int32


# typedef struct {
# 	int parent;
# 	int off_num;
# 	int mnum;
# 	int kai;
# 	int max;
# 	int pos;
# 	char *title;
# 	DEBUG_SUB_MENU submenu[10];
# } DEBUG_MENU;
class DEBUG_MENU(CStructure):
    parent: c_int32
    off_num: c_int32
    mnum: c_int32
    kai: c_int32
    max: c_int32
    pos: c_int32
    title: c_str
    submenu: DEBUG_SUB_MENU * 10


###########################################################################
# typedef struct { // 0x10
# 	/* 0x0 */ u_int type;
# 	/* 0x4 */ u_char rgba[4];
# 	/* 0x8 */ float lscl;
# 	/* 0xc */ float tscl;
# } EFRENZ;
class EFRENZ(CStructure):
    type: c_uint32
    rgba: c_uint8 * 4
    lscl: c_float
    tscl: c_float


###########################################################################
# typedef struct { // 0x50
# 	/* 0x00 */ sceVu0FVECTOR bpos;
# 	/* 0x10 */ sceVu0FVECTOR brot;
# 	/* 0x20 */ sceVu0FVECTOR lpos;
# 	/* 0x30 */ float ww;
# 	/* 0x34 */ float hh;
# 	/* 0x38 */ int power;
# 	/* 0x3c */ u_char r;
# 	/* 0x3d */ u_char g;
# 	/* 0x3e */ u_char b;
# 	/* 0x3f */ u_char a;
# 	/* 0x40 */ void *adr;
# } SUNSHINE;
class SUNSHINE(CStructure, align=16):
    bpos: sceVu0FVECTOR
    brot: sceVu0FVECTOR
    lpos: sceVu0FVECTOR
    ww: c_float
    hh: c_float
    power: c_int32
    r: c_uint8
    g: c_uint8
    b: c_uint8
    a: c_uint8
    adr: c_addr_ptr


# typedef struct {
# 	sceVu0FVECTOR ligdiff;
# 	sceVu0FVECTOR ligpos;
# 	sceVu0FVECTOR fpos;
# 	void *ebuf;
# 	float ligpow;
# 	float wavew;
# 	float rate;
# 	float szw;
# 	float szh;
# 	float sw;
# 	float sh;
# 	u_short furn_id;
# 	u_char lignum;
# 	u_char usefl;
# 	u_char sta;
# } BURN_FIRE;
class BURN_FIRE(CStructure, align=16):
    ligdiff: sceVu0FVECTOR
    ligpos: sceVu0FVECTOR
    fpos: sceVu0FVECTOR
    ebuf: c_addr_ptr
    ligpow: c_float
    wavew: c_float
    rate: c_float
    szw: c_float
    szh: c_float
    sw: c_float
    sh: c_float
    furn_id: c_uint16
    lignum: c_uint8
    usefl: c_uint8
    sta: c_uint8


# typedef struct {
# 	void *adr;
# 	short int furn_id;
# 	u_short dummy;
# } EFFRDR_RSV;
class EFFRDR_RSV(CStructure):
    adr: c_addr_ptr
    furn_id: c_int16
    dummy: c_uint16


###########################################################################
# typedef struct {
# 	u_short pk2;
# 	u_short mpk;
# 	u_short acs;
# 	u_short anm;
# 	u_short bwc;
# 	u_short clt;
# } PLYR_FILE_ID;
class PLYR_FILE_ID(CStructure):
    pk2: c_uint16
    mpk: c_uint16
    acs: c_uint16
    anm: c_uint16
    bwc: c_uint16
    clt: c_uint16


###########################################################################
# typedef struct {
# 	float rot0;
# 	float rot1;
# 	float spd;
# 	u_short timer;
# 	u_short move_type;
# } PLYR_FURI_DAT;
class PLYR_FURI_DAT(CStructure):
    rot0: c_float
    rot1: c_float
    spd: c_float
    timer: c_uint16
    move_type: c_uint16


###########################################################################
# typedef struct { // 0x8
# 	/* 0x0 */ SPRT_DAT *spr;
# 	/* 0x4 */ u_int num;
# } RARE_ENE_1DAT;
class RARE_ENE_1DAT(CStructure):
    spr: c_addr_ptr
    num: c_uint32


# typedef struct { // 0x10
# 	/* 0x0 */ RARE_ENE_1DAT *re1d;
# 	/* 0x4 */ float sclw;
# 	/* 0x8 */ float sclh;
# 	/* 0xc */ u_short attr;
# 	/* 0xe */ u_char attr_sub;
# 	/* 0xf */ u_char pat;
# } RARE_ENE_DAT;
class RARE_ENE_DAT(CStructure):
    re1d: c_addr_ptr
    sclw: c_float
    sclh: c_float
    attr: c_uint16
    attr_sub: c_uint8
    pat: c_uint8


###########################################################################
# typedef struct { // 0x40
# 	/* 0x00 */ u_int attr1;
# 	/* 0x04 */ u_short dst_gthr;
# 	/* 0x06 */ u_char way_gthr;
# 	/* 0x07 */ u_char atk_ptn;
# 	/* 0x08 */ u_char wspd;
# 	/* 0x09 */ u_char rspd;
# 	/* 0x0a */ u_short hp;
# 	/* 0x0c */ u_short atk_rng;
# 	/* 0x0e */ u_short hit_rng;
# 	/* 0x10 */ u_short chance_rng;
# 	/* 0x12 */ short int hit_adjx;
# 	/* 0x14 */ u_short atk_p;
# 	/* 0x16 */ u_short atk_h;
# 	/* 0x18 */ u_char atk;
# 	/* 0x19 */ u_char atk_tm;
# 	/* 0x1a */ u_short mdl_no;
# 	/* 0x1c */ u_short anm_no;
# 	/* 0x20 */ u_int se_no;
# 	/* 0x24 */ u_int adpcm_no;
# 	/* 0x28 */ int dead_adpcm;
# 	/* 0x2c */ u_short point_base;
# 	/* 0x2e */ u_char hint_pic;
# 	/* 0x2f */ u_char aura_alp;
# 	/* 0x30 */ u_char area[6];
# 	/* 0x36 */ u_short dir;
# 	/* 0x38 */ u_short px;
# 	/* 0x3a */ short int py;
# 	/* 0x3c */ u_short pz;
# } ENE_DAT;
class ENE_DAT(CStructure):
    attr1: c_uint32
    dst_gthr: c_uint16
    way_gthr: c_uint8
    atk_ptn: c_uint8
    wspd: c_uint8
    rspd: c_uint8
    hp: c_uint16
    atk_rng: c_uint16
    hit_rng: c_uint16
    chance_rng: c_uint16
    hit_adjx: c_int16
    atk_p: c_uint16
    atk_h: c_uint16
    atk: c_uint8
    atk_tm: c_uint8
    mdl_no: c_uint16
    anm_no: c_uint16
    se_no: c_uint32
    adpcm_no: c_uint32
    dead_adpcm: c_int32
    point_base: c_uint16
    hint_pic: c_uint8
    aura_alp: c_uint8
    area: c_uint8 * 6
    dir: c_uint16
    px: c_uint16
    py: c_int16
    pz: c_uint16


# typedef struct { // 0x20
# 	/* 0x00 */ u_char dat_no;
# 	/* 0x01 */ u_char soul_no;
# 	/* 0x02 */ u_short dir;
# 	/* 0x04 */ u_short px;
# 	/* 0x06 */ short int py;
# 	/* 0x08 */ u_short pz;
# 	/* 0x0a */ u_short adpcm_tm;
# 	/* 0x0c */ int adpcm_no;
# 	/* 0x10 */ u_short rng;
# 	/* 0x12 */ u_short mdl_no;
# 	/* 0x14 */ u_short anm_no;
# 	/* 0x16 */ u_short point_base;
# 	/* 0x18 */ u_int se_no;
# 	/* 0x1c */ int se_foot;
# } AENE_INFO_DAT;
class AENE_INFO_DAT(CStructure):
    dat_no: c_uint8
    soul_no: c_uint8
    dir: c_uint16
    px: c_uint16
    py: c_int16
    pz: c_uint16
    adpcm_tm: c_uint16
    adpcm_no: c_int32
    rng: c_uint16
    mdl_no: c_uint16
    anm_no: c_uint16
    point_base: c_uint16
    se_no: c_uint32
    se_foot: c_int32


# typedef struct { // 0x8
# 	/* 0x0 */ u_short dmg;
# 	/* 0x2 */ u_short hit_rng;
# 	/* 0x4 */ u_short mdl_no;
# 	/* 0x6 */ u_short cond;
# } FLY_DATA;
class FLY_DATA(CStructure):
    dmg: c_uint16
    hit_rng: c_uint16
    mdl_no: c_uint16
    cond: c_uint16


###########################################################################
# typedef struct { // 0x6
# 	/* 0x0 */ u_char destination_id;
# 	/* 0x1 */ u_char message_id;
# 	/* 0x2 */ u_short face_id;
# 	/* 0x4 */ u_short adpcm_id;
# } WANDER_SOUL_DAT;
class WANDER_SOUL_DAT(CStructure):
    destination_id: c_uint8
    message_id: c_uint8
    face_id: c_uint16
    adpcm_id: c_uint16


###########################################################################
# typedef struct {
# 	float center[3];
# 	float r;
# } SPHERE;
class SPHERE(CStructure):
    center: c_float * 3
    r: c_float


# typedef struct {
# 	float p0[3];
# 	float p1[3];
# 	float r;
# 	u_int axis;
# } TUBE;
class TUBE(CStructure):
    p0: c_float * 3
    p1: c_float * 3
    r: c_float
    axis: c_uint32


# typedef struct {
# 	u_char *name;
# 	float mass;
# 	float Ks;
# 	float dec;
# 	sceVu0FVECTOR pos;
# 	sceVu0FVECTOR gravity;
# } WMIM;
class WMIM(CStructure):
    name: c_addr_ptr
    mass: c_float
    Ks: c_float
    dec: c_float
    pos: sceVu0FVECTOR
    gravity: sceVu0FVECTOR


# typedef struct {
# 	WMIM *dat;
# 	u_char bone_id;
# } WMIM_DAT;
class WMIM_DAT(CStructure):
    dat: c_addr_ptr
    bone_id: c_uint8


# typedef struct {
# 	float *vtx;
# 	float gravity;
# 	float Kd;
# 	float Ke;
# 	u_int fixed_num;
# } ROPE_DAT;
class ROPE_DAT(CStructure):
    vtx: c_addr_ptr
    gravity: c_float
    Kd: c_float
    Ke: c_float
    fixed_num: c_uint32


# typedef struct {
# 	float gravity;
# 	float Kd;
# 	float Ke;
# 	u_char w;
# 	u_char h;
# 	u_char type;
# } CLOTH;
class CLOTH(CStructure):
    gravity: c_float
    Kd: c_float
    Ke: c_float
    w: c_uint8
    h: c_uint8
    type: c_uint8


# typedef struct {
# 	void *dat;
# 	u_char type;
# 	u_char bone_id;
# } COLLISION_DAT;
class COLLISION_DAT(CStructure):
    dat: c_addr_ptr
    type: c_uint8
    bone_id: c_uint8


# typedef struct {
# 	CLOTH *dat;
# 	sceVu0FVECTOR *rist_vtx;
# 	u_char bone_id;
# 	u_char bone_id2;
# 	u_char sgd_id;
# 	u_char flg;
# } CLOTH_DAT;
class CLOTH_DAT(CStructure):
    dat: c_addr_ptr
    rist_vtx: c_addr_ptr
    bone_id: c_uint8
    bone_id2: c_uint8
    sgd_id: c_uint8
    flg: c_uint8


###########################################################################
# typedef struct {
# 	sceVu0FVECTOR p;
# 	sceVu0FVECTOR i;
# 	float roll;
# 	float fov;
# 	float nearz;
# 	float farz;
# 	float ax;
# 	float ay;
# 	float cx;
# 	float cy;
# 	float zmin;
# 	float zmax;
# 	float pad[2];
# 	sceVu0FMATRIX vs;
# 	sceVu0FMATRIX vc;
# 	sceVu0FMATRIX vcv;
# 	sceVu0FMATRIX wv;
# 	sceVu0FMATRIX ws;
# 	sceVu0FMATRIX wc;
# 	sceVu0FMATRIX wcv;
# 	sceVu0FVECTOR zd;
# 	sceVu0FVECTOR yd;
# } SgCAMERA;
class SgCAMERA(CStructure):
    p: sceVu0FVECTOR
    i: sceVu0FVECTOR
    roll: c_float
    fov: c_float
    nearz: c_float
    farz: c_float
    ax: c_float
    ay: c_float
    cx: c_float
    cy: c_float
    zmin: c_float
    zmax: c_float
    pad: c_float * 2
    vs: sceVu0FMATRIX
    vc: sceVu0FMATRIX
    vcv: sceVu0FMATRIX
    wv: sceVu0FMATRIX
    ws: sceVu0FMATRIX
    wc: sceVu0FMATRIX
    wcv: sceVu0FMATRIX
    zd: sceVu0FVECTOR
    yd: sceVu0FVECTOR


###########################################################################
# typedef struct {
# 	u_short file_no;
# 	u_char file_type;
# 	u_char tmp_no;
# 	u_int addr;
# } MSN_LOAD_DAT;
class MSN_LOAD_DAT(CStructure):
    file_no: c_uint16
    file_type: c_uint8
    tmp_no: c_uint8
    addr: HEX_ADDR


###########################################################################
# typedef struct {
# 	u_short start;
# 	u_short end;
# 	u_short type;
# } SCN_VIB_DATA;
class SCN_VIB_DATA(CStructure):
    start: c_uint16
    end: c_uint16
    type: c_uint16


# typedef struct {
# 	int time0;
# 	int time1;
# 	int val;
# } SCN_VIB_TYPE;
class SCN_VIB_TYPE(CStructure):
    time0: c_int32
    time1: c_int32
    val: c_int32


# typedef struct {
# 	u_int type;
# 	float sclx;
# 	float scly;
# 	u_int alpha;
# 	float rate;
# 	float trate;
# } SCN_ENE_EF_PDF;
class SCN_ENE_EF_PDF(CStructure):
    type: c_uint32
    sclx: c_float
    scly: c_float
    alpha: c_uint32
    rate: c_float
    trate: c_float


# typedef struct {
# 	u_short scene_no;
# 	u_short mdl_no;
# 	float aura_size;
# 	float aura_rate;
# 	u_int aura_rgba;
# 	SCN_ENE_EF_PDF pdf1;
# 	SCN_ENE_EF_PDF pdf2;
# 	float pdf_dist;
# 	float aura_pos_ajst;
# 	int mdl_alpha;
# } SCN_ENE_EFCT;
class SCN_ENE_EFCT(CStructure):
    scene_no: c_int16
    mdl_no: c_int16
    aura_size: c_float
    aura_rate: c_float
    aura_rgba: c_uint32
    pdf1: SCN_ENE_EF_PDF
    pdf2: SCN_ENE_EF_PDF
    pdf_dist: c_float
    aura_pos_ajst: c_float
    mdl_alpha: c_int32


###########################################################################
# typedef struct {
# 	float scale;
# 	u_char neck_id;
# 	u_char waist_id;
# 	u_char leg_id;
# 	WMIM_DAT *wdat;
# 	CLOTH_DAT *cdat;
# 	COLLISION_DAT *collision;
# } MANMDL_DAT;
class MANMDL_DAT(CStructure):
    scale: c_float
    neck_id: c_uint8
    waist_id: c_uint8
    leg_id: c_uint8
    wdat: c_addr_ptr
    cdat: c_addr_ptr
    collision: c_addr_ptr


###########################################################################
# typedef struct {
# 	u_char scn_no;
# 	MSN_LOAD_DAT *load_dat;
# 	u_short *del_dat;
# } SCN_LOAD_DAT;
class SCN_LOAD_DAT(CStructure):
    scn_no: c_uint8
    load_dat: c_addr_ptr
    del_dat: c_addr_ptr


###########################################################################
# typedef struct {
# 	u_short score;
# 	u_char efct_no;
# 	u_char room;
# 	short pos[3];
# } PGOST_DAT;
class PGOST_DAT(CStructure):
    score: c_uint16
    efct_no: c_uint8
    room: c_uint8
    pos: c_int16 * 3


###########################################################################
# typedef struct {
#     u_short st_x0;
#     short st_y0;
#     u_short st_z0;
#     u_short st_x1;
#     short st_y1;
#     u_short st_z1;
#     u_short ed_x0;
#     short ed_y0;
#     u_short ed_z0;
#     u_short ed_x1;
#     short ed_y1;
#     u_short ed_z1;
# } SGEF_DAT;
class SGEF_DAT(CStructure):
    st_x0: c_uint16
    st_y0: c_int16
    st_z0: c_uint16
    st_x1: c_uint16
    st_y1: c_int16
    st_z1: c_uint16
    ed_x0: c_uint16
    ed_y0: c_int16
    ed_z0: c_uint16
    ed_x1: c_uint16
    ed_y1: c_int16
    ed_z1: c_uint16


###########################################################################
# typedef struct {
# 	u_char room_no;
# 	u_char ene_type;
# 	u_char pos_num;
# 	u_short cmr_no;
# 	u_short rot[3];
# 	int pos[3][3];
# } FGST_AP_DAT;
class FGST_AP_DAT(CStructure):
    room_no: c_uint8
    ene_type: c_uint8
    pos_num: c_uint8
    cmr_no: c_uint16
    rot: c_uint16 * 3
    pos: c_int32 * 3 * 3


# typedef struct {
# 	u_char room;
# 	u_char ap_step0;
# 	u_char ap_step1[4];
# 	u_char ap_step2[6];
# 	u_short ap_near;
# 	u_short ap_far;
# 	u_short ap_stts;
# } RGOST_AP_DAT;
class RGOST_AP_DAT(CStructure):
    room: c_uint8
    ap_step0: c_uint8
    ap_step1: c_uint8 * 4
    ap_step2: c_uint8 * 6
    ap_near: c_uint16
    ap_far: c_uint16
    ap_stts: c_uint16


# typedef struct {
# 	u_short score;
# 	u_char center_no;
# 	u_char center_num;
# 	u_char start;
# 	u_char inter;
# 	u_char end;
# 	u_char dummy;
# 	short int pos[3];
# } RGOST_DAT;
class RGOST_DAT(CStructure):
    score: c_uint16
    center_no: c_uint8
    center_num: c_uint8
    start: c_uint8
    inter: c_uint8
    end: c_uint8
    dummy: c_uint8
    pos: c_int16 * 3


# typedef struct {
# 	u_short flame;
# 	u_char alp_no;
# 	u_char ani_no;
# 	u_char efct_no;
# 	u_char rate_no;
# } RG_DISP_DAT;
class RG_DISP_DAT(CStructure):
    flame: c_uint16
    alp_no: c_uint8
    ani_no: c_uint8
    efct_no: c_uint8
    rate_no: c_uint8


# typedef struct {
# 	u_short flame;
# 	u_char alp;
# 	u_char stts;
# } RG_ALP_DAT;
class RG_ALP_DAT(CStructure):
    flame: c_uint16
    alp: c_uint8
    stts: c_uint8


# typedef struct {
# 	u_char flame;
# 	u_char tim_no;
# } RG_ANI_DAT;
class RG_ANI_DAT(CStructure):
    flame: c_uint8
    tim_no: c_uint8


# typedef struct {
# 	u_short flame;
# 	u_char rate;
# 	u_char stts;
# } RG_RATE_DAT;
class RG_RATE_DAT(CStructure):
    flame: c_uint16
    rate: c_uint8
    stts: c_uint8


###########################################################################
# typedef struct {
#     sceVu0FVECTOR pos;
#     u_char floor;
# } FREE_DAT;
class FREE_DAT(CStructure, align=16):
    pos: sceVu0FVECTOR
    floor: c_uint8


###########################################################################
# typedef struct {
#     u_short attr_no;
#     u_short dist_n;
#     u_short dist_f;
#     u_short score;
#     u_short fact_no;
#     u_char fp_num;
#     u_char fp_no;
#     u_char fp_rot;
#     u_char fp_mak;
#     u_char acs_flg;
#     u_char ef_type;
#     u_char ef_no;
# } FURN_DAT;
class FURN_DAT(CStructure):
    attr_no: c_uint16
    dist_n: c_uint16
    dist_f: c_uint16
    score: c_uint16
    fact_no: c_uint16
    fp_num: c_uint8
    fp_no: c_uint8
    fp_rot: c_uint8
    fp_mak: c_uint8
    acs_flg: c_uint8
    ef_type: c_uint8
    ef_no: c_uint8


###########################################################################
# typedef struct {
# 	u_short time;
# 	u_short score;
# 	u_short rank[5];
# 	u_char clear;
# 	u_char film[2];
# 	u_char reiseki;
# 	u_char map_no;
# 	u_char room;
# 	u_char floor;
# 	u_char ene_no[3];
# 	u_char ene_ap[3];
# 	u_char rgst_no[5];
# 	u_short fly_mdl_no;
# 	short int prot;
# 	sceVu0FVECTOR ppos;
# 	sceVu0FVECTOR epos[3];
# 	sceVu0FVECTOR rgpos[5];
# } STAGE_DAT;
class STAGE_DAT(CStructure):
    time: c_uint16
    score: c_uint16
    rank: c_uint16 * 5
    clear: c_uint8
    film: c_uint8 * 2
    reiseki: c_uint8
    map_no: c_uint8
    room: c_uint8
    floor: c_uint8
    ene_no: c_uint8 * 3
    ene_ap: c_uint8 * 3
    rgst_no: c_uint8 * 5
    fly_mdl_no: c_uint16
    prot: c_int16
    _pad_0: c_uint8 * 12
    ppos: sceVu0FVECTOR
    epos: sceVu0FVECTOR * 3
    rgpos: sceVu0FVECTOR * 5


###########################################################################
# typedef struct {
# 	u_char *str;
# 	int pos_x;
# 	int pos_y;
# 	int type;
# 	u_int r;
# 	u_int g;
# 	u_int b;
# 	int alpha;
# 	int pri;
# } STR_DAT;
class STR_DAT(CStructure):
    str: c_str
    pos_x: c_int32
    pos_y: c_int32
    type: c_int32
    r: c_uint32
    g: c_uint32
    b: c_uint32
    alpha: c_int32
    pri: c_int32


# typedef struct {
# 	u_int w;
# 	u_int h;
# 	int x;
# 	int y;
# 	u_int pri;
# 	u_char r;
# 	u_char g;
# 	u_char b;
# 	u_char alpha;
# } SQAR_DAT;
class SQAR_DAT(CStructure):
    w: c_uint32
    h: c_uint32
    x: c_int32
    y: c_int32
    pri: c_uint32
    r: c_uint8
    g: c_uint8
    b: c_uint8
    alpha: c_uint8


# typedef struct {
#     u_char move_num;
#     u_char empty_no;
#     u_char start[5];
#     u_char line[10];
# } STAR_PZL_DAT;
class STAR_PZL_DAT(CStructure):
    move_num: c_uint8
    empty_no: c_uint8
    start: c_uint8 * 5
    line: c_uint8 * 10


# typedef struct {
#     u_char dial_num;
#     u_char lock_door;
#     u_char dial_no[5];
# } DIAL_KEY_DAT;
class DIAL_KEY_DAT(CStructure):
    dial_num: c_uint8
    lock_door: c_uint8
    dial_no: c_uint8 * 5


# typedef struct {
#     u_char answer;
#     u_char order[9];
#     u_char unfade_doll[3];
#     u_char pad;
# } EV_DOLL_DAT;
class EV_DOLL_DAT(CStructure):
    answer: c_uint8
    order: c_uint8 * 9
    unfade_doll: c_uint8 * 3
    pad: c_uint8


# typedef struct {
#     short int use_flg;
#     short int set_place;
# } EV_BTZ_DAT;
class EV_BTZ_DAT(CStructure):
    use_flg: c_int16
    set_place: c_int16


# typedef struct {
#     short int t_counter;
#     short int bld_apr[10];
#     short int bld_end[10];
#     short int pad;
# } EV_BLD_DAT;
class EV_BLD_DAT(CStructure):
    t_counter: c_int16
    bld_apr: c_int16 * 10
    bld_end: c_int16 * 10
    pad: c_int16


# typedef struct {
#     short int cdl_flg[3][6];
#     short int flame_alpha[6];
#     short int flame_shape[6];
#     short int stflame_alpha[6];
#     short int stflame_shape[6];
#     short int flame_time[6];
#     short int stflame_time[6];
# } EV_CDL_DAT;
class EV_CDL_DAT(CStructure):
    cdl_flg: c_int16 * 6 * 3
    flame_alpha: c_int16 * 6
    flame_shape: c_int16 * 6
    stflame_alpha: c_int16 * 6
    stflame_shape: c_int16 * 6
    flame_time: c_int16 * 6
    stflame_time: c_int16 * 6


# typedef struct {
#     u_char answer;
#     u_char ansflg;
# } ZUSHI_WRK;
class ZUSHI_WRK(CStructure):
    answer: c_uint8
    ansflg: c_uint8


# typedef struct {
#     u_char no;
#     u_char ret;
#     u_char mode;
#     u_char time;
#     u_char count;
#     u_char csr[3];
# } SPECIAL_EVENT_WRK;
class SPECIAL_EVENT_WRK(CStructure):
    no: c_uint8
    ret: c_uint8
    mode: c_uint8
    time: c_uint8
    count: c_uint8
    csr: c_uint8 * 3


# typedef struct {
#     u_char pzl_no;
#     u_char mode;
#     u_char menu_mode;
#     u_char menu_csr[2];
#     u_char time;
#     u_char count;
#     u_char empty;
#     u_char slct_no;
#     u_char bak_no[10];
#     u_char stone[5];
#     u_char line[5][5];
# } STAR_PZL_WRK;
class STAR_PZL_WRK(CStructure):
    pzl_no: c_uint8
    mode: c_uint8
    menu_mode: c_uint8
    menu_csr: c_uint8 * 2
    time: c_uint8
    count: c_uint8
    empty: c_uint8
    slct_no: c_uint8
    bak_no: c_uint8 * 10
    stone: c_uint8 * 5
    line: c_uint8 * 5 * 5


# typedef struct {
#     u_char door_no;
#     u_char mode;
#     u_char time;
#     u_char count;
#     u_char slct_no;
#     u_char push;
#     u_char btn[10];
#     u_char push_no[5];
# } DIAL_KEY_WRK;
class DIAL_KEY_WRK(CStructure):
    door_no: c_uint8
    mode: c_uint8
    time: c_uint8
    count: c_uint8
    slct_no: c_uint8
    push: c_uint8
    btn: c_uint8 * 10
    push_no: c_uint8 * 5


###########################################################################
# typedef struct {
# 	u_short attribute;
# 	short int open_wait;
# 	short int close_wait;
# 	short int move_max;
# 	int se_file;
# 	u_char room_id;
# 	u_short dbl_did;
# } DOOR_TYPE_DAT;
class DOOR_TYPE_DAT(CStructure):
    attribute: c_uint16
    open_wait: c_int16
    close_wait: c_int16
    move_max: c_int16
    se_file: c_int32
    room_id: c_uint8
    dbl_did: c_uint16


# typedef struct {
# 	float sx;
# 	float sy;
# 	u_char dmd_no1;
# 	u_char dmd_no2;
# 	u_char anm_no;
# 	u_char anm_last_no;
# 	u_char c_dmd_no1;
# 	u_char c_dmd_no2;
# 	u_char c_anm_no;
# } DOOR_MTN_DAT;
class DOOR_MTN_DAT(CStructure):
    sx: c_float
    sy: c_float
    dmd_no1: c_uint8
    dmd_no2: c_uint8
    anm_no: c_uint8
    anm_last_no: c_uint8
    c_dmd_no1: c_uint8
    c_dmd_no2: c_uint8
    c_anm_no: c_uint8


# typedef struct {
# 	u_short st_tbl_pos;
# 	u_short start_cnt;
# 	u_short end_cnt;
# 	u_short sel_cnt;
# } DOOR_MOVE_DAT;
class DOOR_MOVE_DAT(CStructure):
    st_tbl_pos: c_uint16
    start_cnt: c_uint16
    end_cnt: c_uint16
    sel_cnt: c_uint16


###########################################################################
# typedef struct {
# 	u_char type;
# 	u_char dummy;
# 	u_short after;
# 	u_short pos_x;
# 	u_short pos_y;
# 	u_short msg_no;
# } FIND_DAT;
class FIND_DAT(CStructure):
    type: c_uint8
    dummy: c_uint8
    after: c_uint16
    pos_x: c_uint16
    pos_y: c_uint16
    msg_no: c_uint16


###########################################################################
# typedef struct {
# 	float pos_x;
# 	float pos_y;
# 	float pos_z;
# 	float fscl;
# 	float kscl;
# 	u_char fr;
# 	u_char fg;
# 	u_char fb;
# 	u_char kr;
# 	u_char kg;
# 	u_char kb;
# } FURN_EFCT_FIRE;
class FURN_EFCT_FIRE(CStructure):
    pos_x: c_float
    pos_y: c_float
    pos_z: c_float
    fscl: c_float
    kscl: c_float
    fr: c_uint8
    fg: c_uint8
    fb: c_uint8
    kr: c_uint8
    kg: c_uint8
    kb: c_uint8


# typedef struct {
# 	float pos_x;
# 	float pos_y;
# 	float pos_z;
# 	float lpos_x;
# 	float lpos_y;
# 	float lpos_z;
# 	float rot_x;
# 	float rot_y;
# 	float rot_z;
# 	float w;
# 	float h;
# 	int power;
# 	u_char r;
# 	u_char g;
# 	u_char b;
# } FURN_EFCT_SUNSHINE;
class FURN_EFCT_SUNSHINE(CStructure):
    pos_x: c_float
    pos_y: c_float
    pos_z: c_float
    lpos_x: c_float
    lpos_y: c_float
    lpos_z: c_float
    rot_x: c_float
    rot_y: c_float
    rot_z: c_float
    w: c_float
    h: c_float
    power: c_int32
    r: c_uint8
    g: c_uint8
    b: c_uint8


# typedef struct {
# 	u_char sclw;
# 	u_char sclh;
# } FURN_EFCT_DEFORM;
class FURN_EFCT_DEFORM(CStructure):
    sclw: c_uint8
    sclh: c_uint8


###########################################################################
# typedef struct {
# 	u_char item_no;
# 	u_char stts;
# 	u_char room;
# 	u_char msn_no;
# 	short int pos_x;
# 	short int pos_y;
# 	short int pos_z;
# 	u_short get_msg[2];
# } MAP_ITEM_DAT;
class MAP_ITEM_DAT(CStructure):
    item_no: c_uint8
    stts: c_uint8
    room: c_uint8
    msn_no: c_uint8
    pos_x: c_int16
    pos_y: c_int16
    pos_z: c_int16
    get_msg: c_uint16 * 2


# typedef struct {
# 	u_char stts;
# 	u_char room;
# 	short int pos_x;
# 	short int pos_y;
# 	short int pos_z;
# 	u_char get_msg[2];
# 	u_char dsp_pct;
# 	u_char msn_no;
# 	u_char map_dsp;
# } MAP_FILE_DAT;
class MAP_FILE_DAT(CStructure):
    stts: c_uint8
    room: c_uint8
    pos_x: c_int16
    pos_y: c_int16
    pos_z: c_int16
    get_msg: c_uint8 * 2
    dsp_pct: c_uint8
    msn_no: c_uint8
    map_dsp: c_uint8


###########################################################################
# typedef struct {
#     u_short time;
#     float magnif;
# } FSPE_LIGHT_ANM;
class FSPE_LIGHT_ANM(CStructure):
    time: c_uint16
    magnif: c_float


###########################################################################
# typedef struct {
# 	u_char type;
# 	u_char value0;
# 	short int value1;
# } ITEM_USE_DAT;
class ITEM_USE_DAT(CStructure):
    type: c_uint8
    value0: c_uint8
    value1: c_int16


###########################################################################
# typedef struct {
#     short int disp_pos;
#     short int attribute;
#     SPRT_DAT *ssd_p[4];
#     short int flp_num[4];
#     short int dat_idx[2];
#     short int pad;
# } RELATION_COM;
class RELATION_COM(CStructure):
    disp_pos: c_int16
    attribute: c_int16
    ssd_p: c_addr_ptr * 4
    flp_num: c_int16 * 4
    dat_idx: c_int16 * 2
    pad: c_int16


# typedef struct {
# 	RELATION_PRT *left_prt;
# 	RELATION_PRT *right_prt;
# 	SPRT_DAT *ssd_p;
# 	short int st_index[4];
# 	short int start_no;
# 	short int end_no;
# 	short int attribute;
# 	int csr_y;
# 	short int wk_scl[8][2];
# 	short int wk_pos[2][4];
# 	short int mission_no;
# } RELATION_PRT;
class RELATION_PRT(CStructure):
    left_prt: c_addr_ptr
    right_prt: c_addr_ptr
    ssd_p: c_addr_ptr
    st_index: c_int16 * 4
    start_no: c_int16
    end_no: c_int16
    attribute: c_int16
    csr_y: c_int32
    wk_scl: c_int16 * 2 * 8
    wk_pos: c_int16 * 4 * 2
    mission_no: c_int16


###########################################################################
# typedef struct {
#     ATION_DAT *up_p;
#     ATION_DAT *down_p;
#     ATION_DAT *left_p;
#     ATION_DAT *right_p;
#     ATION_PRT *parent_p;
#     ATION_NAME_PLATE *plate_p;
#     T_DAT *ssd_p;
#     T_DAT *fnt_p;
#     T_DAT *fla_p;
#     short int dat_idx;
#     short int attribute;
#     short int msg_idx;
#     short int tm2_id;
#     short int dsp_pos;
#     short int pad;
# } RELATION_DAT;
class RELATION_DAT(CStructure):
    up_p: c_addr_ptr
    down_p: c_addr_ptr
    left_p: c_addr_ptr
    right_p: c_addr_ptr
    parent_p: c_addr_ptr
    plate_p: c_addr_ptr
    ssd_p: c_addr_ptr
    fnt_p: c_addr_ptr
    fla_p: c_addr_ptr
    dat_idx: c_int16
    attribute: c_int16
    msg_idx: c_int16
    tm2_id: c_int16
    dsp_pos: c_int16
    pad: c_int16


# typedef struct {
#     short int x;
#     short int y;
#     short int u;
#     short int v;
#     short int exp_u;
#     short int exp_v;
#     short int n_rabel;
#     short int tbl_no;
#     short int pad;
# } RELATION_NAME_PLATE;
class RELATION_NAME_PLATE(CStructure):
    x: c_int16
    y: c_int16
    u: c_int16
    v: c_int16
    exp_u: c_int16
    exp_v: c_int16
    n_rabel: c_int16
    tbl_no: c_int16
    pad: c_int16


# typedef struct {
#     short int com_idx;
#     short int attribute;
#     short int x1;
#     short int y1;
#     short int len;
#     short int pad;
# } RELATION_YAJI;
class RELATION_YAJI(CStructure):
    com_idx: c_int16
    attribute: c_int16
    x1: c_int16
    y1: c_int16
    len: c_int16
    pad: c_int16


# typedef struct {
#     short int x;
#     short int y;
#     short int no;
#     short int pnl;
# } CAPTION_LIST;
class CAPTION_LIST(CStructure):
    x: c_int16
    y: c_int16
    no: c_int16
    pnl: c_int16


# typedef struct {
#     short int x;
#     short int y;
#     u_char mark;
#     u_char str;
# } CAPTION_DATA_SUB;
class CAPTION_DATA_SUB(CStructure):
    x: c_int16
    y: c_int16
    mark: c_uint8
    str: c_uint8


# typedef struct {
#     short int w;
#     short int h;
#     CAPTION_DATA_SUB cds[4];
# } CAPTION_DATA;
class CAPTION_DATA(CStructure):
    w: c_int16
    h: c_int16
    cds: CAPTION_DATA_SUB * 4


# typedef struct {
#     short int px;
#     short int py;
#     short int sx;
#     short int sy;
# } DSP_PHT;
class DSP_PHT(CStructure):
    px: c_int16
    py: c_int16
    sx: c_int16
    sy: c_int16


###########################################################################
# typedef struct {
#     short int pos_x;
#     short int pos_y;
#     u_short siz_x;
#     u_short siz_y;
#     u_char win_no;
# } MSK_SIZ;
class MSK_SIZ(CStructure):
    pos_x: c_int16
    pos_y: c_int16
    siz_x: c_uint16
    siz_y: c_uint16
    win_no: c_uint8


# typedef struct {
#     short int pos_x;
#     short int pos_y;
#     u_short siz_x;
#     u_short siz_y;
#     u_char u_hgh;
#     u_char d_hgh;
#     u_char l_wid;
#     u_char r_wid;
#     u_char pri;
#     u_char bak;
# } WIN_PTN;
class WIN_PTN(CStructure):
    pos_x: c_int16
    pos_y: c_int16
    siz_x: c_uint16
    siz_y: c_uint16
    u_hgh: c_uint8
    d_hgh: c_uint8
    l_wid: c_uint8
    r_wid: c_uint8
    pri: c_uint8
    bak: c_uint8


# typedef struct {
#     short int pos_x;
#     short int pos_y;
#     u_short siz_x;
#     u_short siz_y;
#     u_char win_no;
# } PLS_LIN;
class PLS_LIN(CStructure):
    pos_x: c_int16
    pos_y: c_int16
    siz_x: c_uint16
    siz_y: c_uint16
    win_no: c_uint8


###########################################################################
# typedef struct {
# 	short int px;
# 	short int py;
# 	u_char rt;
# 	u_char flr;
# 	u_char id;
# } MAP_DOOR_POS;
class MAP_DOOR_POS(CStructure):
    px: c_int16
    py: c_int16
    rt: c_uint8
    flr: c_uint8
    id: c_uint8


# typedef struct {
# 	u_short px;
# 	u_short py;
# 	short int rt;
# 	u_char flr;
# 	u_char room;
# } MAP_SVP_POS;
class MAP_SVP_POS(CStructure):
    px: c_uint16
    py: c_uint16
    rt: c_int16
    flr: c_uint8
    room: c_uint8


###########################################################################
# typedef struct {
# 	u_short mdl_no;
# 	u_short knd;
# 	u_short no;
# 	u_short msn;
# } GLIST_ORDER;
class GLIST_ORDER(CStructure):
    mdl_no: c_uint16
    knd: c_uint16
    no: c_uint16
    msn: c_uint16


elf_names: dict[str, str] = {
    "us": "SLUS_203.88",
    "eu": "SLES_508.21",
}


class VRamElf(BinaryIO):
    def __init__(self, elf: BinaryIO):
        self.elf = elf

    def read(self, n: int = -1):
        return self.elf.read(n)

    def seek(self, offset: int, whence: int = 0):
        return self.elf.seek(vram2offset(offset), whence)


# matches "var_name = 0x12345678; // attr1:val1 attr2:val2 ... attrN:valN"
line_pattern = re.compile(r"^([^\s=]+)\s*=\s*(0x[0-9a-fA-F]+);\s*\/\/((?:\s*[0-9a-zA-Z_]+(:?:[0-9a-zA-Z_\*]+)?)+)\s*$")
# matches multiple attributes in the form of attr:val or attr
attr_pattern = re.compile(r"([0-9a-zA-Z_]+)(?::([0-9a-zA-Z_\*]+))?")
# match address lines: "0xaabbccdd = &var"
addr_pattern = re.compile(r"^\s*(0x[0-9a-fA-F]+)\s*=\s*(.*)\s*;\s*(\/\/.*)?$")


class DataVar(pydantic.BaseModel):
    model_config = pydantic.ConfigDict(extra="forbid")

    _elf: VRamElf = pydantic.PrivateAttr()

    address: int
    name: str
    type: Type[CStructure] | CTypeType | type[sceVu0FVECTOR] | type[sceVu0IVECTOR] | type[qword] | type[c_str]
    numel: int | list[int] = 0
    nosize: bool = False
    static: bool = False

    num_ptr: int = 0

    @pydantic.model_validator(mode="after")
    def store_num_ptr(self):
        # transfer class attribute to instance
        if DataVar.num_ptr > 0:
            self.num_ptr = DataVar.num_ptr
        return self

    @pydantic.field_validator("type", mode="before")
    @classmethod
    def type_from_str(  # pyright: ignore
        cls, v: str | Type[CStructure] | CTypeType
    ) -> Type[CStructure] | CTypeType | sceVu0FVECTOR | sceVu0IVECTOR | qword | ANI_CODE | GS_REG | HEX_ADDR:
        if not isinstance(v, str):
            return v
        cls.num_ptr = v.count("*")  # temporary store num_ptr in class attribute
        v = v.rstrip("*")  # remove pointer(s)
        if v in ctypes_types:
            return ctypes_types[v]
        if v == "sceVu0FVECTOR":
            return sceVu0FVECTOR
        if v == "sceVu0IVECTOR":
            return sceVu0IVECTOR
        if v == "qword":
            return qword
        if v == "ANI_CODE":
            return ANI_CODE
        if v == "GS_REG":
            return GS_REG
        if v == "HEX_ADDR":
            return HEX_ADDR
        if v == "c_str":
            return c_str
        class_type = globals()[v]
        if issubclass(class_type, CStructure):
            return class_type
        raise ValueError(f"{v} is unknown/not a valid type")

    def data_var_dumps(self, addresses: dict[int, str]):
        self._elf.seek(self.address, os.SEEK_SET)

        if isinstance(self.numel, list):
            numel = math.prod(self.numel)
            ndims = len(self.numel)
        else:
            numel = max(1, self.numel)
            ndims = 1
        if self.num_ptr > 0:
            var_data = (c_addr_ptr * numel).from_buffer_copy(self._elf.read(numel * c_sizeof(c_addr_ptr)))
            if self.type == ANI_CODE:  # pyright: ignore
                type_str = "ANI_CODE" + ("*" * self.num_ptr)
            if self.type == GS_REG:  # pyright: ignore
                type_str = "u_long" + ("*" * self.num_ptr)
            if self.type == HEX_ADDR:  # pyright: ignore
                type_str = "u_int" + ("*" * self.num_ptr)
            elif issubclass(self.type, CStructure):  # pyright: ignore
                type_str = self.type.__name__ + ("*" * self.num_ptr)
            elif self.type == sceVu0FVECTOR:  # pyright: ignore
                type_str = "sceVu0FVECTOR" + ("*" * self.num_ptr)
            elif self.type == sceVu0IVECTOR:  # pyright: ignore
                type_str = "sceVu0IVECTOR" + ("*" * self.num_ptr)
            else:
                type_str = next(
                    k
                    for k, v in ctypes_types.items()
                    if getattr(v, "_type_") == getattr(self.type, "_type_")  # pyright: ignore
                ) + ("*" * self.num_ptr)
            stream = io.StringIO()
            if self.static:
                stream.write("static ")
            stream.write(f"{type_str} {self.name}")
            if numel > 1:
                numel = f"{self.numel}" if not self.nosize else ""
                var_str = f"{{ {', '.join(str(var) for var in cast(Iterable[c_addr_ptr], var_data))}, }}"  # pyright: ignore
                stream.write(f"[{numel}]")
            else:
                # should have been parsed as c_float_Array_4_Array_1
                assert len(var_data) == 1 and var_data[0].__class__ is c_addr_ptr
                var_str = str(var_data[0])
            stream.write(f" = {var_str};")
        elif issubclass(self.type, CStructure):  # pyright: ignore
            data = self._elf.read(numel * self.type.sizeof())

            return self.type.dumps(
                self.name,
                data,
                numel=self.numel,
                static=self.static,
                nosize=self.nosize,
                noarray=self.numel == 0,
            )
        elif self.type == sceVu0FVECTOR:  # pyright: ignore[reportUnknownMemberType]
            var_data = (sceVu0FVECTOR * numel).from_buffer_copy(self._elf.read(numel * c_sizeof(sceVu0FVECTOR)))
            type_str = "sceVu0FVECTOR"
            stream = io.StringIO()
            if self.static:
                stream.write("static ")
            stream.write(f"{type_str} {self.name}")

            def sceVu0FVECTOR_to_str(_v: sceVu0FVECTOR):  # pyright: ignore
                return f"{{ {', '.join(f'{flt}f' for flt in cast(Iterable[c_float], _v))} }}"

            if numel > 1:
                numel = f"{self.numel}" if not self.nosize else ""
                var_str = (
                    f"{{ {', '.join(sceVu0FVECTOR_to_str(var) for var in cast(Iterable[sceVu0FVECTOR], var_data))}, }}"  # pyright: ignore
                )
                stream.write(f"[{numel}]")
            else:
                # should have been parsed as c_float_Array_4_Array_1
                assert len(var_data) == 1 and var_data[0].__class__ is sceVu0FVECTOR
                var_str = sceVu0FVECTOR_to_str(var_data[0])
            stream.write(f" = {var_str};")
        elif self.type == sceVu0IVECTOR:  # pyright: ignore[reportUnknownMemberType]
            var_data = (sceVu0IVECTOR * numel).from_buffer_copy(self._elf.read(numel * c_sizeof(sceVu0IVECTOR)))
            type_str = "sceVu0IVECTOR"
            stream = io.StringIO()
            if self.static:
                stream.write("static ")
            stream.write(f"{type_str} {self.name}")

            def sceVu0IVECTOR_to_str(_v: sceVu0IVECTOR):  # pyright: ignore
                return f"{{ {', '.join(f'{int32}' for int32 in cast(Iterable[c_int32], _v))} }}"

            if numel > 1:
                numel = f"{self.numel}" if not self.nosize else ""
                var_str = (
                    f"{{ {', '.join(sceVu0IVECTOR_to_str(var) for var in cast(Iterable[sceVu0IVECTOR], var_data))}, }}"  # pyright: ignore
                )
                stream.write(f"[{numel}]")
            else:
                # should have been parsed as c_int_Array_4_Array_1
                assert len(var_data) == 1 and var_data[0].__class__ is sceVu0IVECTOR
                var_str = sceVu0IVECTOR_to_str(var_data[0])
            stream.write(f" = {var_str};")
        elif self.type == c_str:  # pyright: ignore
            assert numel > 1, "we only handle string arrays here, simple strings should be embedded in the source"
            var_data = (self.type * numel).from_buffer_copy(self._elf.read(numel * c_sizeof(self.type)))  # pyright: ignore
            stream = io.StringIO()
            if self.static:
                stream.write("static ")
            numel = f"{self.numel}" if not self.nosize else ""
            stream.write(f"char *{self.name}[{numel}] = {{")
            for var in cast(Iterable[c_str], var_data):
                stream.write(f"{var.to_str(self._elf)},")
            stream.write("};")
        else:
            typ = self.type  # pyright: ignore
            if ndims == 1:
                typ *= numel  # pyright: ignore
            elif isinstance(self.numel, list):
                for n in reversed(self.numel):
                    typ *= n  # pyright: ignore
            var_data = (typ).from_buffer_copy(self._elf.read(numel * c_sizeof(self.type)))  # pyright: ignore
            if self.type.__name__ == "ANI_CODE":  # pyright: ignore
                type_str = "ANI_CODE"
            elif self.type.__name__ == "GS_REG":  # pyright: ignore
                type_str = "u_long"
            elif self.type.__name__ == "HEX_ADDR":  # pyright: ignore
                type_str = "u_int"
            else:
                type_str = next(
                    k
                    for k, v in ctypes_types.items()
                    if getattr(v, "_type_") == getattr(self.type, "_type_")  # pyright: ignore
                )
            stream = io.StringIO()
            if self.static:
                stream.write("static ")
            stream.write(f"{type_str} {self.name}")
            if ndims == 1:
                numel = f"{self.numel}" if not self.nosize else ""
                var_str = f"{{ {', '.join(f'{var}' for var in cast(Iterable[CTypeType], var_data))} }}"
                stream.write(f"[{numel}]")
            elif ndims > 1:
                assert isinstance(self.numel, list)
                numel = ""
                for n, num in enumerate(self.numel):
                    numel += "[]" if n == 0 and self.nosize else f"[{num}]"
                stream.write(numel)
                tmpbuf = io.StringIO()
                tmpbuf.write("{")
                print_carr(var_data, tmpbuf)  # pyright: ignore
                tmpbuf.write("}")
                var_str = tmpbuf.getvalue()
            else:
                var_str = f"{var_data.value}"  # pyright: ignore
            stream.write(f" = {var_str};")
        return stream.getvalue()


def parse_data_vars(data_vars_txt: Path, strict: bool = True):
    data_vars: list[DataVar] = []
    addr_vals: dict[int, str] = {}

    with open(data_vars_txt, mode="r") as fh:
        for n, line in enumerate(fh):
            line = line.strip()

            # skip empty lines and comments
            if not line or line.startswith("//"):
                continue

            valid = False

            if addr_match := addr_pattern.match(line):
                address = int(addr_match.group(1), 16)
                value = addr_match.group(2)
                addr_vals[address] = value
                valid = True

            elif line_match := line_pattern.match(line):
                address = int(line_match.group(2), 16)
                options = line_match.group(3)
                name = line_match.group(1)
                if attr_match := attr_pattern.findall(options):
                    attrs: dict[str, str | list[str] | bool] = {}
                    for attr_name, attr_val in cast(list[tuple[str, str]], attr_match):
                        if attr_name not in attrs:
                            attrs[attr_name] = attr_val
                        elif not isinstance(attrs[attr_name], list):
                            attrs[attr_name] = cast(list[str], [attrs[attr_name], attr_val])
                        else:
                            cast(list[str], attrs[attr_name]).append(attr_val)
                    for key, value in attrs.items():
                        if not isinstance(value, bool) and len(value) == 0:
                            attrs[key] = True
                    try:
                        data_var = DataVar(address=address, name=name, **attrs)  # pyright: ignore[reportArgumentType]
                        data_vars.append(data_var)
                        if address not in addr_vals:
                            if (
                                isinstance(data_var.numel, list) or data_var.numel > 0 or data_var.type == sceVu0FVECTOR  # type: ignore
                            ):
                                addr_vals[address] = name
                            else:
                                addr_vals[address] = f"&{name}"
                        valid = True
                    except pydantic.ValidationError as ve:
                        print(f"syntax error at line {n}")
                        raise ve

            if strict and not valid:
                raise ValueError(f"syntax error at line {n}: {line}")

    return data_vars, addr_vals


def parse_data(lang: str):
    data_vars_txt = Path("config") / lang / "data_vars.txt"

    data_vars, addr_vals = parse_data_vars(data_vars_txt)

    if not data_vars:
        return

    if len(set(data_var.name for data_var in data_vars)) != len(data_vars):
        raise RuntimeError("duplicate names in data_vars.txt")

    elf_path = Path("config") / lang / elf_names[lang]

    include_path = Path("config") / lang / "include" / "data"
    include_path.mkdir(parents=True, exist_ok=True)

    c_addr_ptr.set_addresses(addr_vals)

    extract_filter: list[str] = []
    extract_filter_str = os.environ.get("EXTRACT_DATA_FILTER", "").strip()
    if extract_filter_str:
        extract_filter: list[str] = extract_filter_str.split(",")

    with open(elf_path, mode="rb") as elf:
        vram_elf = VRamElf(elf)
        CStructure.__elf__ = vram_elf

        for data_var in tqdm.tqdm(data_vars, desc="Extracting data"):
            header_path = include_path / f"{data_var.name}.h"

            if extract_filter and data_var.name not in extract_filter:
                continue

            with header_path.open(mode="w") as fw:
                data_var._elf = vram_elf  # pyright: ignore[reportPrivateUsage]

                fw.write(data_var.data_var_dumps(addr_vals))

            try:
                subprocess.run(["clang-format", "-i", "--style=Microsoft", header_path])
            except Exception:
                # formatting is best effort for now
                pass


def main():
    class Language(str, enum.Enum):
        US = "us"
        EU = "eu"

    languages = [lang.value for lang in Language]

    class ArgsProtocol(Protocol):
        language: Language

    parser = argparse.ArgumentParser(description="fixes asm removing gp_rel macro")
    parser.add_argument("language", type=str, choices=languages, help="language to extract data for")

    args = cast(ArgsProtocol, parser.parse_args())

    parse_data(args.language)


if __name__ == "__main__":
    main()