interface ValueType<T> {
  read(buffer: BufferSource, offset: number): T
  write?(value: any, context: WriteContext, offset: number): void
  SIZE: number
}

type Rule = (...params: any) => (dataObj: any, buffer: BufferSource) => boolean

/**
 * Represents the structure of a C-like Struct
 */
declare class Struct implements ValueType<Struct> {

  /**
   * Creates a new struct definition
   * @param name Optional name. Only used for debugging purposes
   */
  constructor(name?: string)

  /**
   * Adds a member to load
   * @param type Datatype of the member to load
   * @param name Name of the member
   */
  addMember(type: ValueType<any>, name: string): this

  /**
   * Adds a an array to load from values inside this struct. The order is not important
   * @param type Datatype of the member to load
   * @param name Name of the member
   * @param offset Number or name of the member which stores the address of the array
   * @param count Number or name of the member which stores the length of the array
   * @param relative Is the address in the target member relative to the structs address?
   */
  addArray(type: ValueType<any>, name: string, offset: string | number, count: string | number, relative?: boolean): this
  
  /**
   * Adds a reference. This marks a member as pointer. References will appear as own members in the out data. Recursive references are allowed and will produce an circular structure.
   * @param type Type of the reference
   * @param name Name of the new data member
   * @param offset Number or name of member containing the offset
   * @param relative Is the address relative to the structs address?
   */
  addReference(type: ValueType<any>, name: string, offset: string | number, relative?: boolean): this

  /**
   * Adds a rule. Rules give extra validation options
   * @param rule The rule to add. Rules can be generated with the static methods of Struct.RULES
   */
  addRule(rule: Rule): this

  /**
   * Adds a static value. Will be attached to every read object. Statics have no have any influence on the binary data!
   * @param name 
   * @param value 
   */
  addStatic(name, value): this

  /**
   * Converts a buffer to an object with the structs structure
   * @param buffer Buffer to read from
   * @param offset Offset byte to start reading from
   * @returns {Object} The data that was read
   */
  read(buffer: BufferSource, offset: number, readContext?: ReadContext): any

  /**
   * Parses an givien buffer. Returns the read context. It will contain the extracted data as well as some statistics like how many bytes were read and what errors occoured.
   * @param buffer Buffer to read from
   * @param offset Offset byte to start reading from
   * @param options Parsing options
   * @returns The report
   */
  readContext(buffer: BufferSource, offset: number, options: ReadOptions): ReadContext

  /**
   * Writes data to an buffer, using this structure
   * @param any Data holding object
   * @param WriteContext Internally used for the write process. Will create automatically a new one if none is given
   * @param number Offset, for start writing
   */
  write(object: object, context?: WriteContext = null, offset?: number = 1): WriteContext

  /**
   * Validates a structure
   * @param buffer Buffer to read from
   * @param offset Byte offset in the buffer to begin reading from
   * @returns True when valid 
   */
  validate(buffer: BufferSource, offset?: number): boolean

  /**
   * Returns the relative offset of an attribute in this struct definition
   * @param name Name of the attribute
   * @returns Relative offset in bytes
   */
  getOffsetByName(name: string): number

  /**
   * The size, an instance of this struct will occupy. This does not contain the content of arrays.
   */
  get SIZE(): number

  /**
   * Inbuilt rules
   */
  static RULES: {
    EQUAL: Rule
  }

  /**
   * Inbuilt types
   */
  static TYPES: {

    /* 
     * Signed 4 byte little-endian Integer 
     */
    INT: ValueType<number>
    INT_LE: ValueType<number>

    /**
     * Signed 4 byte big-endian Integer
     */
    INT_BE: ValueType<number>

    /**
     * Unsigned 4 byte little-endian integer
     */
    UINT: ValueType<number>
    UINT_LE: ValueType<number>

    /**
     * Unsigned 4 byte big-endian Integer
     */
    UINT_BE: ValueType<number>

    /**
     * Signed 16 bit little-endian integer
     */
    SHORT: ValueType<number>
    SHORT_LE: ValueType<number>

    /**
     * Signed 16 bit big-endian integer
     */
    SHORT_BE: ValueType<number>

    /**
     * Unsigned 16 bit little-endian integer
     */
    USHORT: ValueType<number>
    USHORT_LE: ValueType<number>

    /**
     * Unsigned 16 bit big-endian integer
     */
    USHORT_BE: ValueType<number>

    /**
     * 4 Byte little-endian float
     */
    FLOAT: ValueType<number>
    FLOAT_LE: ValueType<number>

    /**
     * 4 Byte big-endian float
     */
    FLOAT_BE: ValueType<number>

    /**
     * 1 ASCII character 
     */
    CHAR: ValueType<string>

    /**
     * Unsigned 8 bit int
     */
    BYTE: ValueType<number>

    /**
     * String with fixed Length
     * @param {number} length Length to read
     * @param {=string} encoding Codec to use. Anything that is supported by buffer.toString()
     */
    STRING(length: number, encoding: string|"ascii"): ValueType<string>

    /**
     * Null terminated string. Don't use this type in a struct. Only as reference!
     * @param encoding Codec to use. Anything that is supported by buffer.toString()
     */
    NULL_TERMINATED_STRING(encoding: string|"ascii"): ValueType<string>

    /**
     * Skips a given amount of bytes
     * @param length Number of bytes to skip
     */
    SKIP(length: number): ValueType<void>
  }
}

type ReadOptions = {

  /**
   * Calculate how much of the source buffer was read
   */
  monitorUsage?: boolean

  /**
   * Remove reference fields (array offset, array length and reference offset fields) from output data.
   */
  hideReferenceValues?: boolean
}

/**
 * Stores the result of an import/read.
 */
declare class ReadContext {

  constructor(buffer: BufferSource, options: ReadOptions)

  /**
   * Returns a formatted string containing the reports result.
   */
  toString(): string

  /**
   * Returns the number of read bytes. Returns NaN, if monitorUsage is false
   */
  getUsage(): number

  /**
   * Returns true if the imported data had errors
   */
  hasErrors(): boolean

  /**
   * Raw data read
   */
  data: object
  
}

type WriteOptions = {

  /**
   * Output buffer size in bytes
   */
  bufferSize?: number
}

declare class WriteContext {

  /**
   * Output buffer
   */
  public buffer: Buffer;

  constructor(options: WriteOptions)

}

export = Struct;