// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package io.v.v23.vom;

import com.google.common.collect.ImmutableMultimap;
import com.google.common.reflect.TypeToken;

import junit.framework.TestCase;

import io.v.v23.vdl.Types;
import io.v.v23.vdl.VdlAny;
import io.v.v23.vdl.VdlInt32;
import io.v.v23.vdl.VdlOptional;
import io.v.v23.vdl.VdlType;
import io.v.v23.vdl.VdlTypeObject;
import io.v.v23.vdl.VdlUint32;
import io.v.v23.vdl.VdlValue;
import io.v.v23.vom.testdata.data80.Constants;
import io.v.v23.vom.testdata.types.ConvertGroup;

import java.lang.reflect.Type;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Tests for value conversions.
 */
public class ConversionTest extends TestCase {
    private final ImmutableMultimap<VdlValue, Type> tests =
            ImmutableMultimap.<VdlValue, Type>builder()
            .put(VdlOptional.of(new VdlUint32()), VdlInt32.class)
            .put(VdlOptional.of(new VdlUint32()),
                    new TypeToken<VdlOptional<VdlInt32>>(){}.getType())
            .put(new VdlUint32(), VdlInt32.class)
            .put(new VdlUint32(), new TypeToken<VdlOptional<VdlInt32>>(){}.getType())
            .put(new VdlAny(new VdlUint32()), VdlInt32.class)
            .put(new VdlAny(new VdlUint32()), VdlAny.class)
            .put(new VdlUint32(), VdlAny.class)
            .build();

    private static Object convert(Version version, VdlValue value, Type targetType) throws Exception {
        byte[] encoded = TestUtil.hexStringToBytes(TestUtil.encode(version, value));
        return TestUtil.decode(encoded, targetType);
    }

    public void testConversion() throws Exception {
        Version version = Version.DEFAULT_VERSION;
        for (Map.Entry<VdlValue, Type> test : tests.entries()) {
            final byte[] encoded = TestUtil.hexStringToBytes(TestUtil.encode(version, test.getKey()));
            final Object decoded = TestUtil.decode(encoded, test.getValue());
            Class<?> targetClass = ReflectUtil.getRawClass(test.getValue());
            assertEquals(targetClass, decoded.getClass());
        }

        for (List<ConvertGroup> test : Constants.CONVERT_TESTS.values()) {
            for (int i = 0; i < test.size(); i++) {
                ConvertGroup g = test.get(i);
                for (VdlAny value : g.getValues()) {
                    // Everything inside a convert group is convertible.
                    for (VdlAny otherValue : g.getValues()) {
                        Type targetType;
                        if (value.getElem().getClass().isArray()) {
                            targetType = value.getElem().getClass();
                        } else {
                            targetType = Types.getReflectTypeForVdl(value.getElemType());
                        }
                        TestUtil.assertEqual(String.format("convert %s -> %s == %s", otherValue, targetType, value.getElem()), value.getElem(), convert(version, otherValue, targetType));
                    }
                    // Element of one convert group can't be converted to primary type of
                    // previous groups.
                    for (int j = 0; j < i; j++) {
                        Type targetType = Types.getReflectTypeForVdl(
                                test.get(j).getPrimaryType().getTypeObject());
                        try {
                            convert(version, value, targetType);
                            fail("Converted " + value + " -> " + targetType);
                        } catch (Exception expected) {
                        }
                    }
                }
            }
        }
    }

    public void testTypeCompatibility() throws Exception {
        Map<VdlType, String> vdlTypes = new HashMap<VdlType, String>();
        for (Map.Entry<String, List<VdlTypeObject>> testGroup : Constants.COMPAT_TESTS.entrySet()) {
            for (VdlTypeObject type : testGroup.getValue()) {
                vdlTypes.put(type.getTypeObject(), testGroup.getKey());
            }
        }
        for (Map.Entry<VdlType, String> i : vdlTypes.entrySet()) {
            for (Map.Entry<VdlType, String> j : vdlTypes.entrySet()) {
                boolean compatible = TypeCompatibility.compatible(i.getKey(), j.getKey());
                assertEquals("Types: " + i.getKey() + ", " + j.getKey(),
                        i.getValue().equals(j.getValue()), compatible);
            }
        }
    }
}