module DBusTests;

import DBusTestsInterfaces;
import org.freedesktop.dbus.Variant;
import org.freedesktop.dbus.DBus;

import tango.core.Signal;
import tango.io.Stdout;

void main(char[][] args) {
    if( args.length != 2 ){
            Stderr.formatln( "there is not exaclty one argument" );
    }
    Stdout.formatln("... started D app ...");
    DirectConnection dc = new DirectConnection( args[1] );
    Stdout.formatln("Connected");
    auto o = new Tests();
    o.registerDBusObject( dc.conn );
    Stdout.formatln("Export obj : {}", o.getDBusInstanceName() );
Stdout.flush();
    dc.mainLoop();
    Stdout.formatln("Disconnected");
Stdout.flush();
Stderr.flush();
}


class Tests : DBusObject, DBusInterface.dbustests.Tests {
    public this(){
        super();
        signalVoid().attach( & detectSignalVoid );
        signalInt().attach( & detectSignalInt );
        signalStruct().attach( & detectSignalStruct );
        signalArray().attach( & detectSignalArray );
    }
    public void identityVoid(){
    }
    public bool identityBool(in bool input ){
        return input;
    }
    public byte identityByte(in byte input ){
        return input;
    }
    public short identityShort(in short input ){
        return input;
    }
    public ushort identityUShort(in ushort input ){
        return input;
    }
    public int identityInt(in int input ){
        return input;
    }
    public uint identityUInt(in uint input ){
        return input;
    }
    public long identityLong(in long input ){
        //Stdout.formatln( "D: identityLong {}", input ).flush();
        return input;
    }
    public ulong identityULong(in ulong input ){
        return input;
    }
    public double identityDouble(in double input ){
        return input;
    }
    public char[] identityString(in char[] input ){
        return input;
    }
    public DBusVariant identityVariant(in DBusVariant input ){
        return input;
    }

    public bool[] identityArrayBool(in bool[] input ){
        Stdout.formatln( "identityArrayBool length {}", input.length );
        return input.dup;
    }
    public byte[] identityArrayByte(in byte[] input ){
        return input;
    }
    public short[] identityArrayShort(in short[] input ){
        return input;
    }
    public ushort[] identityArrayUShort(in ushort[] input ){
        return input;
    }
    public int[] identityArrayInt(in int[] input ){
        return input;
    }
    public uint[] identityArrayUInt(in uint[] input ){
        return input;
    }
    public long[] identityArrayLong(in long[] input ){
        return input;
    }
    public ulong[] identityArrayULong(in ulong[] input ){
        return input;
    }
    public double[] identityArrayDouble(in double[] input ){
        return input;
    }
    public char[][] identityArrayString(in char[][] input ){
        return input;
    }
    public DBusVariant[] identityArrayVariant(in DBusVariant[] input ){
        return input;
    }
    public long Sum(in int[] input ){
        long res;
        foreach( v; input ){
            res += v;
        }
        return res;
    }
    public uint Sum(in byte[] input ){
        long res;
        foreach( v; input ){
            res += v;
        }
        return res;
    }
    public char[][][ char[] ] InvertMapping(in char[][ char[] ] input ){
        Stderr.formatln( "InvertMapping();" ).flush;
        char[][][ char[] ] res;
        foreach( k, v; input ){
            if( v in res ){
                char[][] data = res[ v ];
                data ~= k.dup;
                res[ v ] = data;
            }
            else{
                res[ v.dup ] = [k.dup];
            }
        }
        Stderr.formatln( "InvertMapping();" ).flush;
        return res;
    }
    public void DeStruct(
        in Struct!( char[], uint, short ) input,
        out char[] res_1,
        out uint   res_2,
        out short  res_3 )
    {
        res_1 = input.t[0];
        res_2 = input.t[1];
        res_3 = input.t[2];
    }

    public DBusVariant[] Primitize(in DBusVariant input ){
        DBusVariant[] res;
        return null;
    }
    public bool Invert(in bool input ){
        return !input;
    }

    // ------------------------------------------
    Signal!() signalVoid_;
    public Signal!()* signalVoid(){
        return & signalVoid_;
    }
    private void detectSignalVoid(){
        Stdout.formatln( "signalVoid();" );
    }
    // ------------------------------------------
    Signal!( int ) signalInt_;
    public Signal!( int )* signalInt(){
        return & signalInt_;
    }
    private void detectSignalInt( int v ){
        Stdout.formatln( "signalInt({});", v );
    }
    // ------------------------------------------
    Signal!( Struct!( char[], uint, short ) ) signalStruct_;
    public Signal!( Struct!( char[], uint, short ) )* signalStruct(){
        return & signalStruct_;
    }
    private void detectSignalStruct( Struct!( char[], uint, short ) value ){
        Stdout.formatln( "signalStruct( Struct!( {}, {}, {} ) );", value.t[0], value.t[1], value.t[2] );
    }
    // ------------------------------------------
    Signal!( Struct!( char[], uint, short )[] ) signalArray_;
    public Signal!( Struct!( char[], uint, short )[] )* signalArray(){
        return & signalArray_;
    }
    private void detectSignalArray(Struct!( char[], uint, short )[] value ){
        Stdout.formatln( "signalArray() with {} elements", value.length );
        foreach( v; value ){
            Stdout.formatln( "  {} {} {}", v.t[0], v.t[1], v.t[2] );
        }
        Stdout.flush;
    }
    // ------------------------------------------
    Signal!( DBusVariant ) signalVariant_;
    public Signal!( DBusVariant )* signalVariant(){
        return & signalVariant_;
    }
    // ------------------------------------------

}