/**
 * This test demonstrates director classes when the types are classes. Shown are
 * virtual function calls which use classes passed by
 *  - Value
 *  - Reference
 *  - Pointer
 * as both parameters and return values
 *
 * The test also demonstrates directors used with:
 *  - method overloading
 *  - default parameters
 *
 * Note: Methods with default parameters that call up from C++ cannot call the
 * overloaded D methods, see DefaultParms method.

 * Expected output if PrintDebug enabled:
 * ------------ Start ------------
 * Base - Val(444.555)
 * Base - Ref(444.555)
 * Base - Ptr(444.555)
 * Base - FullyOverloaded(int 10)
 * Base - FullyOverloaded(bool 1)
 * Base - SemiOverloaded(int -678)
 * Base - SemiOverloaded(bool 1)
 * Base - DefaultParms(10, 2.2)
 * Base - DefaultParms(10, 1.1)
 * --------------------------------
 * Derived - Val(444.555)
 * Derived - Ref(444.555)
 * Derived - Ptr(444.555)
 * Derived - FullyOverloaded(int 10)
 * Derived - FullyOverloaded(bool 1)
 * Derived - SemiOverloaded(int -678)
 * Base - SemiOverloaded(bool 1)
 * Derived - DefaultParms(10, 2.2)
 * Derived - DefaultParms(10, 1.1)
 * --------------------------------
 * DDerived - Val(444.555)
 * DDerived - Ref(444.555)
 * DDerived - Ptr(444.555)
 * DDerived - FullyOverloaded(int 10)
 * DDerived - FullyOverloaded(bool True)
 * DDerived - SemiOverloaded(-678)
 * Base - SemiOverloaded(bool 1)
 * DDerived - DefaultParms(10, 2.2)
 * DDerived - DefaultParms(10, 1.1)
 * ------------ Finish ------------
 */
module director_classes_runme;

import tango.io.Stdout;
import tango.text.Util;
import director_classes.director_classes;
import director_classes.Caller;
import director_classes.Base;
import director_classes.Derived;
import director_classes.DoubleHolder;

void main() {
  if (PrintDebug) Stdout.formatln("------------ Start ------------ ");

  auto myCaller = new Caller();

  // Test C++ base class.
  {
    scope myBase = new Base(100.0);
    makeCalls(myCaller, myBase);
  }

  if (PrintDebug) Stdout.formatln("--------------------------------");

  // Test vanilla C++ wrapped derived class.
  {
    scope myBase = new Derived(200.0);
    makeCalls(myCaller, myBase);
  }

  if (PrintDebug) Stdout.formatln("--------------------------------");

  // Test director / D derived class.
  {
    scope myBase = new DDerived(300.0);
    makeCalls(myCaller, myBase);
  }

  if (PrintDebug) Stdout.formatln("------------ Finish ------------ ");
}

void makeCalls(Caller myCaller, Base myBase) {
  char[] myBaseType = myBase.classinfo.name.split(".")[$-1];
  myCaller.set(myBase);

  DoubleHolder dh = new DoubleHolder(444.555);

  // Class pointer, reference and pass by value tests
  if (myCaller.ValCall(dh).val != dh.val) throw new Exception("[1] failed");
  if (myCaller.RefCall(dh).val != dh.val) throw new Exception("[2] failed");
  if (myCaller.PtrCall(dh).val != dh.val) throw new Exception("[3] failed");

  // Fully overloaded method test (all methods in base class are overloaded)
  if (myCaller.FullyOverloadedCall(10) != myBaseType ~ "::FullyOverloaded(int)") throw new Exception("[4] failed");
  if (myCaller.FullyOverloadedCall(true) != myBaseType ~ "::FullyOverloaded(bool)") throw new Exception("[5] failed");

  // Semi overloaded method test (some methods in base class are overloaded)
  if (myCaller.SemiOverloadedCall(-678) != myBaseType ~ "::SemiOverloaded(int)") throw new Exception("[6] failed");
  if (myCaller.SemiOverloadedCall(true) != "Base" ~ "::SemiOverloaded(bool)") throw new Exception("[7] failed");

  // Default parameters methods test
  if (myCaller.DefaultParmsCall(10, 2.2) != myBaseType ~ "::DefaultParms(int, double)") throw new Exception("[8] failed");
  if (myBase.classinfo == DDerived.classinfo) { // special handling for D derived classes, there is no way to do this any other way
    if (myCaller.DefaultParmsCall(10) != myBaseType ~ "::DefaultParms(int, double)") throw new Exception("[9] failed");
  } else {
    if (myCaller.DefaultParmsCall(10) != myBaseType ~ "::DefaultParms(int)") throw new Exception("[10] failed");
  }

  myCaller.reset();
}

public class DDerived : Base {
  public this(double dd) {
    super(dd);
  }

  public override DoubleHolder Val(DoubleHolder x) {
    if (PrintDebug) Stdout.formatln("DDerived - Val({0:d3})", x.val);
    return x;
  }

  public override DoubleHolder Ref(DoubleHolder x) {
    if (PrintDebug) Stdout.formatln("DDerived - Ref({0:d3})", x.val);
    return x;
  }

  public override DoubleHolder Ptr(DoubleHolder x) {
    if (PrintDebug) Stdout.formatln("DDerived - Ptr({0:d3})", x.val);
    return x;
  }

  public override char[] FullyOverloaded(int x) {
    if (PrintDebug) Stdout.formatln("DDerived - FullyOverloaded(int {0})", x);
    return "DDerived::FullyOverloaded(int)";
  }

  public override char[] FullyOverloaded(bool x) {
    if (PrintDebug) Stdout.formatln("DDerived - FullyOverloaded(bool {0})", x);
    return "DDerived::FullyOverloaded(bool)";
  }

  public override char[] SemiOverloaded(int x) {
    char[] ret = "DDerived::SemiOverloaded(int)";
    if (PrintDebug) Stdout.formatln("DDerived - SemiOverloaded({0})", x);
    return ret;
  }
  alias Base.SemiOverloaded SemiOverloaded; // Alias in SemiOverloaded(bool x).

  public override char[] DefaultParms(int x, double y) {
    char[] ret = "DDerived::DefaultParms(int, double)";
    if (PrintDebug) Stdout.formatln("DDerived - DefaultParms({0}, {1:d1})", x, y);
    return ret;
  }
  // This method will never be called from C++ code because the two-parameter
  // DefaultParams() has a default value for the second parameter there. It is
  // only here to ensure consistent behavior for calls from C++ and D code.
  public override char[] DefaultParms(int x) {
    if (PrintDebug) Stdout.formatln("DDerived - DefaultParms({0})", x);
    return DefaultParms(x, 1.1/*use C++ default here*/);
  }
}
