'use strict';
import { BufferLengthError } from './errors/BufferLengthError';
import { InvalidValueError } from './errors/InvalidValueError';
import { DPT } from './definitions';

/**
 * U 4 bit
 * V 4 bit
 * W 4 bit
 * X 4 bit
 * Y 4 bit
 * Z 4 bit
 * E 1 bit
 * P 1 bit
 * D 1 bit
 * C 1 bit
 * N 4 bit
 *
 * U,V,W,X,Y,Z = [0 … 9]; E,P,D,C = {0,1}; N = [0 … 15]
 *
 * Source: https://www.promotic.eu/en/pmdoc/Subsystems/Comm/PmDrivers/KNXDTypes.htm
 */
export interface DPT15Result {
  U: number
  V: number
  W: number
  X: number
  Y: number
  Z: number
  E: number
  P: number
  D: number
  C: number
  N: number
}
export class DPT15 implements DPT {
  id = '';
  name = '4-byte access control data';
  bufferLength = 4;

  /**
   * Decode a buffer
   *
   * @param buffer the buffer
   * @returns the DPT value
   */
  decoder(buffer: Buffer): DPT15Result {
    if (buffer.length !== this.bufferLength)
      throw new BufferLengthError(`Invalid buffer length ${buffer.length}/${buffer} for DPT8.  Expected ${this.bufferLength}.`);

    const result: DPT15Result = {
      U: (buffer[0] & 0xf0) >> 4,
      V: (buffer[0] & 0x0f),
      W: (buffer[1] & 0xf0) >> 4,
      X: (buffer[1] & 0x0f),
      Y: (buffer[2] & 0xf0) >> 4,
      Z: (buffer[2] & 0x0f),
      E: (buffer[3] >> 7) & 0x01,
      P: (buffer[3] >> 6) & 0x01,
      D: (buffer[3] >> 5) & 0x01,
      C: (buffer[3] >> 4) & 0x01,
      N: (buffer[3] & 0x0f),
    }

    if (Math.max(result.U, result.V, result.W, result.X, result.Y, result.Z) > 9)
      throw new InvalidValueError(`Value must be < 9 (U: ${result.U}, V: ${result.V}, W: ${result.W}, X: ${result.X}, y: ${result.Y}, Z: ${result.Z})`)

    return result;
  };

  /**
   * Encode a buffer
   *
   * @param value the value to be converted to buffer
   * @returns the buffer
   */
  encoder(value: DPT15Result): Buffer {
    if (value === undefined || value === null)
      throw new InvalidValueError(`Invalid value [${value}]`)

    if (Math.max(value.U, value.V, value.W, value.X, value.Y, value.Z) > 9)
      throw new InvalidValueError(`Value must be < 9 (U: ${value.U}, V: ${value.V}, W: ${value.W}, X: ${value.X}, y: ${value.Y}, Z: ${value.Z})`)

    const apdu_data = Buffer.alloc(this.bufferLength);
    apdu_data.writeUInt8((value.U << 4) + value.V, 0);
    apdu_data.writeUInt8((value.W << 4) + value.X, 1);
    apdu_data.writeUInt8((value.Y << 4) + value.Z, 2);
    apdu_data.writeUInt8((value.E << 7) + (value.P << 6) + (value.D << 5) + (value.C << 4) + value.N, 3);
    return apdu_data;
  }


  subtypes: {
    "000": {
      name: "DPT_Access_Data",
      desc: "default field"
    }
  };

}