// Defino un tipo para error que sera un argumento en el callback.
type FunctionCallBackError = Error | null;
// Defino la estructura de la función que debe llegar en el argumento con nombre CallBack
// Esto es un Tipo Function o Function Type.  Recibira dos argumentos, y no retornara nada.
type FunctionCallBack = (error: FunctionCallBackError, response: Object) => void ;

//Llamó a los Types dentro de una función principal, donde tenemos como argumento 
//el callback, y de igual manera si no es null el callback hará el llamado con los argumentos
//que deben corresponder al tipo segun la definicion arriba.
function FuncionPrincipal ( funcionCallback : FunctionCallBack) : void {
  if(funcionCallback)
    funcionCallback(null, { code: '00' });
}

//Definimos la función con sus argumentos y retorno
type FuncionArrow = (funcionCallBack: FunctionCallBack) => void;

//Llamaremos a nuestra función como un arrow function.
const ArrowFunction: FuncionArrow = (callbackFunc: FunctionCallBack): void => {
  if(callbackFunc)
    callbackFunc(null, { code: '00' })
}

//Definimos la funcion que vamos ausar como decorator.
function Historial(target, key) {
  console.log('Function: ' + key);
}

//Definimos la clase.
class Vehiculo {
  model: string;

  constructor(model: string) {
    this.model = model;
  }

  //Empleamos el decorador Historial para la funcion getModel, por lo que cada
  //vez que se ejecute este metodo se va ejecutar el decorador.
  @Historial
  getModel() {
    console.log(this.model);
    return this.model;
  }
}

//Creamos un Objeto con la clase Vehiculo, y llamamos el método getModel
const Carro: Vehiculo = new Vehiculo('Tucson');
Carro.getModel();

//Definimos la función como Init, la cual extenderá Target que es una clase
function init(target) {
  return class extends target {
    marca = 'Hyundai';
    model = super.getModel();  //Podemos traer de la clase original.
    color = 'Azul';

    getModel() {
      return `${this.marca} ${this.model} ${this.color}`;
    }
  };
}

//Definimos la clase con el Decorador
@init
class NuevoVehiculo {
  model: string;

  constructor(model: string) {
    this.model = model;
  }

  getModel() {
    console.log(this.model);
    return this.model;
  }
}

//Creamos un Objeto con la clase Vehiculo, y llamamos el método getModel
const NuevoCarro: NuevoVehiculo = new NuevoVehiculo('Tucson');
NuevoCarro.getModel();
//Esto traera Hyundai Tucson Azul.

//Definimos la función que sera el decorator que efectuara un cambio del año.
function newAnio(target, key) {
  let _valor: number = this[key]; // Tomamos la variable en donde estará el decorador.

  //Generamos los setter and Getter.
  const getter = () => {
    return _valor;
  };

  const setter = (nuevoValor: number) => {
    _valor = nuevoValor - 1;
  };

  //Agregamos al Objeto las propiedades getter and setter
  Object.defineProperty(target, key, { get: getter, set: setter });
}

class VehiculoAnio {
  nombre: string;
  @newAnio
  anio: number;

  constructor(_nombre: string, _anio: number) {
    this.nombre = _nombre;
    this.anio = _anio;
  }
}

const Tucson2016 = new VehiculoAnio('Tucson', 2018);
Tucson2016.anio = 2030;
const FinalAnio = Tucson2016.anio;

function DecoradorDeParametro(target, propertyKey, index) {
  const metadataKey = `log_${propertyKey}_parameters`;
  if(Array.isArray(target[metadataKey])){
    target[metadataKey].push(index);
  } else {
    target[metadataKey] = [index];
  }

  console.log(target);
  console.log(propertyKey);
  console.log(index);
}

class TargetDemoClass {
  public Metodo1(parametro1: any, @DecoradorDeParametro parametroDecorado: any) {
    console.log('Metodo1 en Clase');
  }
}
function Metodo2(parametro2: any, @DecoradorDeParametro parametroDecorado: any) {
  //Error Decoradores no son validos aqui.
  console.log('Funcion Global Metodo2');

}

const UnObjeto: TargetDemoClass = new TargetDemoClass();
UnObjeto.Metodo1('Clase Arg1', 'Clase Arg2 Decorado');
Metodo2('Global Arg1', 'Global Arg2');