#include "WinDurango.Common/Logging.h"
#include "WinDurango.Implementation.WinRT/Interfaces/Storage/Directory.h"
#include "pch.h"
#include <iostream>

using namespace winrt;

using namespace Windows;
using namespace Windows::ApplicationModel;
using namespace Windows::ApplicationModel::Core;
using namespace Windows::Foundation::Numerics;
using namespace Windows::UI;
using namespace Windows::UI::Core;
using namespace Windows::UI::Composition;

struct App : implements<App, IFrameworkViewSource, IFrameworkView>
{
    CompositionTarget m_target{nullptr};
    VisualCollection m_visuals{nullptr};
    Visual m_selected{nullptr};
    float2 m_offset{};
    bool runFirst = true;
    wd::common::Logging logthing;

    IFrameworkView CreateView()
    {
        return *this;
    }

    void Initialize(CoreApplicationView const &)
    {
    }

    void Load(hstring const &)
    {
    }

    void Uninitialize()
    {
    }

    void Run()
    {
        CoreWindow window = CoreWindow::GetForCurrentThread();
        window.Activate();

        CoreDispatcher dispatcher = window.Dispatcher();
        dispatcher.ProcessEvents(CoreProcessEventsOption::ProcessUntilQuit);
    }

    void SetWindow(CoreWindow const &window)
    {
        Compositor compositor;
        ContainerVisual root = compositor.CreateContainerVisual();
        m_target = compositor.CreateTargetForCurrentView();
        m_target.Root(root);
        m_visuals = root.Children();

        window.PointerPressed({this, &App::OnPointerPressed});
        window.PointerMoved({this, &App::OnPointerMoved});

        window.PointerReleased([&](auto &&...) { m_selected = nullptr; });
    }

    void OnPointerPressed(IInspectable const &, PointerEventArgs const &args)
    {
        float2 const point = args.CurrentPoint().Position();

        for (Visual visual : m_visuals)
        {
            float3 const offset = visual.Offset();
            float2 const size = visual.Size();

            if (point.x >= offset.x && point.x < offset.x + size.x && point.y >= offset.y &&
                point.y < offset.y + size.y)
            {
                m_selected = visual;
                m_offset.x = offset.x - point.x;
                m_offset.y = offset.y - point.y;
            }
        }

        if (m_selected)
        {
            m_visuals.Remove(m_selected);
            m_visuals.InsertAtTop(m_selected);
        }
        else
        {
            AddVisual(point);
        }
        if (runFirst)
        {
            Package pkg = Package::Current();
            hstring id = pkg.Id().FamilyName();
            std::wcout << L"Name: " << id.c_str() << L"\n";
            wd::impl::winrt::interfaces::storage::WinRTDirectory dir("");
            dir.open();
            auto wddir = dir.CreateFolder("WinDurango");
            wddir->open();
            auto wdlog = wddir->CreateFile("log.txt");
            wdlog->open();
            (*wdlog) << std::string("Testing");
            logthing = wd::common::Logging(wdlog);
            logthing.Initialize();
            logthing.Log("WinDurango.Testing", "Hi");
            logthing.Warn("WinDurango.Testing", "Bye");
            logthing.Error("WinDurango.Testing", "Oops");
            runFirst = false;
        }
        logthing.Log("WinDurango.Testing", "Click");
    }

    void OnPointerMoved(IInspectable const &, PointerEventArgs const &args)
    {
        if (m_selected)
        {
            float2 const point = args.CurrentPoint().Position();

            m_selected.Offset({point.x + m_offset.x, point.y + m_offset.y, 0.0f});
        }
    }

    void AddVisual(float2 const point)
    {
        Compositor compositor = m_visuals.Compositor();
        SpriteVisual visual = compositor.CreateSpriteVisual();

        static Color colors[] = {
            {0xDC, 0x5B, 0x9B, 0xD5}, {0xDC, 0xED, 0x7D, 0x31}, {0xDC, 0x70, 0xAD, 0x47}, {0xDC, 0xFF, 0xC0, 0x00}};

        static unsigned last = 0;
        unsigned const next = ++last % _countof(colors);
        visual.Brush(compositor.CreateColorBrush(colors[next]));

        float const BlockSize = 100.0f;

        visual.Size({BlockSize, BlockSize});

        visual.Offset({
            point.x - BlockSize / 2.0f,
            point.y - BlockSize / 2.0f,
            0.0f,
        });

        m_visuals.InsertAtTop(visual);

        m_selected = visual;
        m_offset.x = -BlockSize / 2.0f;
        m_offset.y = -BlockSize / 2.0f;
    }
};

int __stdcall main()
{
    CoreApplication::Run(make<App>());
}