#pragma once

using namespace Platform;
namespace WFC = Windows::Foundation::Collections;

#include <collection.h>
#include <algorithm>
#include <cmath>

namespace mycomp
{
        // delegates
    public delegate void PropertyChangedHandler(Object^ source, int i);
    public delegate void SomeHandler(Platform::String^ str);

    // Activatable class.
    public ref class LangSample sealed
    {
        // Backing store for propertyA.
        int _propertyAValue;

    public:
        LangSample()
        {
            _propertyAValue = 21;

        }

        // IVector across the ABI.
        WFC::IVector<int>^ SortVector(WFC::IVector<int>^ vec)
        {
            std::sort(begin(vec), end(vec));
            return vec;
        }

        // IMap
        WFC::IMap<int, Platform::String^> ^GetMap(void)
        {
            WFC::IMap<int, Platform::String^> ^ret = ref new Platform::Map<int, Platform::String^>;            
            ret->Insert(1, "One ");
            ret->Insert(2, "Two ");
            ret->Insert(3, "Three ");
            ret->Insert(4, "Four ");
            ret->Insert(5, "Five ");

            return ret;
        }

        // Property with custom setter/getter
        property int PropertyA
        {
            int get() { return _propertyAValue; }
            void set(int propertyAValue) 
            {
                if (propertyAValue != _propertyAValue)
                {
                    _propertyAValue = propertyAValue;
                    propertyChangedEvent(this, propertyAValue);
                }
            }
        }

        // Trivial get/set property with compiler-generated backing store.
        property Platform::String^ PropertyB;

        // Public method that returns a value of built-in type.
        // Implicit conversion of return value to equivalent WinRT type.
        double LogCalc(double input)
        {       
            
            // Use C++ standard library as usual.
            return std::log(input); 
        }

        // Method that fires an event
        void FireEvent(Platform::String^ str)
        {
            someEvent(Platform::String::Concat(str, PropertyA.ToString()));
        }

        // Method that throws an exception.
        void ExceptionMethod()
        {    
            throw ref new Platform::DisconnectedException();
        }

        // Events. See delegate types above.
        event PropertyChangedHandler^ propertyChangedEvent;
        event SomeHandler^ someEvent;

    };
}
// WinRTComponent.h

<button id="callwinrt" onclick="CallWinRT()">Call WinRT</button>
<p></p>
    <label id ="Label1">Activation Result::  </label><label id ="loaded"></label>
    <p></p>
    <label id ="Label2">Input Vector::  </label><label id ="inputvector"></label>
    <p></p>
    <label id ="Label3">Sorted Vector::  </label><label id ="outputvector"></label>
    <p></p>
    <label id ="Label9">Map output::  </label><label id ="mapoutput"></label>
    <p></p>
    <label id ="Label4">Retrieved property::  </label><label id ="retrievedproperty"></label>
    <p></p>
     <label id ="Label10">Set property::  </label><label id ="setproperty"></label>
    <p></p>
     <label id ="Label11">Call method::  </label><label id ="callmethod"></label>
    <p></p>
    <label id ="Label5">Single Cast Handler called::  </label><label id ="singlecastresult"></label>
    <p></p>
    <label id ="Label6">Multi Cast Handler 1 called::  </label><label id ="multicastresult1"></label>
    <p></p>
    <label id ="Label7">Multi Cast Handler 2 called::  </label><label id ="multicastresult2"></label>
    <p></p>
    <label id ="Label8">Handled Exception::  </label><label id ="handledexception"></label>
    <p></p>

function CallWinRT() {
    // activate the native Windows Runtime component
    var nativeObject = new mycomp.LangSample();
    document.getElementById('loaded').innerHTML = nativeObject;

    // call the method to sort an integer array
    var inVector = [14, 12, 45, 89, 23];
    document.getElementById('inputvector').innerHTML = inVector;

    var outVector = nativeObject.sortVector(inVector);
    document.getElementById('outputvector').innerHTML = outVector;

    // call the method to get the map
    var outputMap = nativeObject.getMap();
    var mStr = outputMap.lookup(1) + outputMap.lookup(2) + outputMap.lookup(3) + outputMap.lookup(4) + outputMap.lookup(5);
    document.getElementById('mapoutput').innerHTML = mStr;

    // get the value of the integer property
    var propValue = nativeObject.propertyA;
    document.getElementById('retrievedproperty').innerHTML = propValue;

    // set a string property
    nativeObject.propertyB = "What is the meaning of the universe?";
    document.getElementById('setproperty').innerHTML = nativeObject.propertyB;

    //call a method
    var num = nativeObject.logCalc(21.5);
    document.getElementById('callmethod').innerHTML = num;

    // add an event handler
    var singlecasthandler = function (ev) {
        document.getElementById('singlecastresult').innerHTML = ev;
    };

    nativeObject.onpropertychangedevent = singlecasthandler;

    // set the value of the integer property.  this should fire an event
    nativeObject.propertyA = 2 * propValue;

    // add multi-cast handlers
    var multicast1 = function (ev) {
        document.getElementById('multicastresult1').innerHTML = ev.target;
    };
    var multicast2 = function (ev) {
        document.getElementById('multicastresult2').innerHTML = ev.target;
    };

    nativeObject.addEventListener("someevent", multicast1);
    nativeObject.addEventListener("someevent", multicast2);

    // this method should fire an event
    nativeObject.fireEvent("The answer is ");

    // call the method that throws an exception
    try {
        nativeObject.exceptionMethod();
    }
    catch (err) {
        document.getElementById('handledexception').innerHTML = err;
    }
}