// Handle playing GIF animations from inside SMXConfig.
//
// This can load two GIF animations, one for when panels are released
// and one for when they're pressed, and play them automatically on the
// pad in the background.  Applications that control lights can do more
// sophisticated things with the lights, but this gives an easy way for
// people to create simple animations.
//
// If you're implementing the SDK in a game, you don't need this and should
// use SMX.h instead.
//
// An animation is a single GIF with animations for all panels, in the
// following layout:
//
// 0000|1111|2222
// 0000|1111|2222
// 0000|1111|2222
// 0000|1111|2222
// --------------
// 3333|4444|5555
// 3333|4444|5555
// 3333|4444|5555
// 3333|4444|5555
// --------------
// 6666|7777|8888
// 6666|7777|8888
// 6666|7777|8888
// 6666|7777|8888
// x-------------
//
// The - | regions are ignored and are only there to space out the animation
// to make it easier to view.
//
// The extra bottom row is a flag row and should normally be black.  The first
// pixel (bottom-left) optionally marks a loop frame.  By default, the animation
// plays all the way through and then loops back to the beginning.  If the loop
// frame pixel is white, it marks a frame to loop to instead of the beginning.
// This allows pressed animations to have a separate lead-in and loop.
//
// Each animation is for a single pad.  You can load the same animation for both
// pads or use different ones.

#include "SMXPanelAnimation.h"
#include "SMXManager.h"
#include "SMXDevice.h"
#include "SMXThread.h"
#include <cmath>
using namespace std;
using namespace SMX;

namespace {
    Mutex g_Lock;
}

#define LIGHTS_PER_PANEL 25

// XXX: go to sleep if there are no pads connected

struct AnimationState
{
    SMXPanelAnimation animation;

    // Seconds into the animation:
    float fTime = 0;

    // The currently displayed frame:
    size_t iCurrentFrame = 0;

    bool bPlaying = false;

    double m_fLastUpdateTime = -1;

    // Return the current animation frame.
    const vector<SMXGif::Color> &GetAnimationFrame() const
    {
        // If we're not playing, return an empty array.  As a sanity check, do this
        // if the frame is out of bounds too.
        if(!bPlaying || iCurrentFrame >= animation.m_aPanelGraphics.size())
        {
            static vector<SMXGif::Color> dummy;
            return dummy;
        }

        return animation.m_aPanelGraphics[iCurrentFrame];
    }

    // Start the animation if it's not playing.
    void Play()
    {
        bPlaying = true;
    }

    // Stop and disable the animation.
    void Stop()
    {
        bPlaying = false;
        Rewind();
    }

    // Reset to the first frame.
    void Rewind()
    {
        fTime = 0;
        iCurrentFrame = 0;
    }

    // Advance the animation by fSeconds.
    void Update()
    {
        // fSeconds is the time since the last update:
        double fNow = SMX::GetMonotonicTime();
        double fSeconds = m_fLastUpdateTime == -1? 0: (fNow - m_fLastUpdateTime);
        m_fLastUpdateTime = fNow;

        if(!bPlaying || animation.m_aPanelGraphics.empty())
            return;

        // If the current frame is past the end, a new animation was probably
        // loaded.
        if(iCurrentFrame >= animation.m_aPanelGraphics.size())
            Rewind();

        // Advance time.
        fTime += fSeconds;

        // If we're still on this frame, we're done.
        float fFrameDuration = animation.m_iFrameDurations[iCurrentFrame];
        if(fTime - 0.00001f < fFrameDuration)
            return;

        // If we've passed the end of the frame, move to the next frame.  Don't
        // skip frames if we're updating too quickly.
        fTime -= fFrameDuration;
        if(fTime > 0)
            fTime = 0;

        // Advance the frame.
        iCurrentFrame++;

        // If we're at the end of the frame, rewind to the loop frame.
        if(iCurrentFrame == animation.m_aPanelGraphics.size())
            iCurrentFrame = animation.m_iLoopFrame;
    }
};

struct AnimationStateForPad
{
    // asLightsData is an array of lights data to send to the pad and graphic
    // is an animation graphic.  Overlay graphic on top of the lights.
    void OverlayLights(char *asLightsData, const vector<SMXGif::Color> &graphic) const
    {
        // Stop if this graphic isn't loaded or is paused.
        if(graphic.empty())
            return;

        for(size_t i = 0; i < graphic.size(); ++i)
        {
            if(i >= LIGHTS_PER_PANEL)
                return;

            // If this color is transparent, leave the released animation alone.
            if(graphic[i].color[3] == 0)
                continue;

            asLightsData[i*3+0] = graphic[i].color[0];
            asLightsData[i*3+1] = graphic[i].color[1];
            asLightsData[i*3+2] = graphic[i].color[2];
        }
    }

    // Return the command to set the current animation state as pad lights.
    string GetLightsCommand(int iPadState, const SMXConfig &config) const
    {
        g_Lock.AssertLockedByCurrentThread();

        // If AutoLightingUsePressedAnimations is set, use lights animations.
        // If it's not (the config tool is set to step color), mimic the built-in
        // step color behavior instead of using pressed animations.  Any released
        // animation will always be used.
        bool bUsePressedAnimations = config.flags & PlatformFlags_AutoLightingUsePressedAnimations;

        const int iBytesPerPanel = LIGHTS_PER_PANEL*3;
        const int iTotalLights = 9*iBytesPerPanel;
        string result(iTotalLights, 0);

        for(int panel = 0; panel < 9; ++panel)
        {
            // The portion of lights data for this panel:
            char *out = &result[panel*iBytesPerPanel];

            // Skip this panel if it's not in autoLightPanelMask.
            if(!(config.autoLightPanelMask & (1 << panel)))
                continue;

            // Add the released animation, then overlay the pressed animation if we're pressed.
            OverlayLights(out, animations[SMX_LightsType_Released][panel].GetAnimationFrame());
            bool bPressed = bool(iPadState & (1 << panel));
            if(bPressed && bUsePressedAnimations)
                OverlayLights(out, animations[SMX_LightsType_Pressed][panel].GetAnimationFrame());
            else if(bPressed && !bUsePressedAnimations)
            {
                // Light all LEDs on this panel using stepColor.
                double LightsScaleFactor = 0.666666f;
                const uint8_t *color = &config.stepColor[panel*3];

                for(int light = 0; light < LIGHTS_PER_PANEL; ++light)
                {
                    for(int i = 0; i < 3; ++i)
                    {
                        // stepColor is scaled to the 0-170 range.  Scale it back to the 0-255 range.
                        // User applications don't need to worry about this since they normally don't
                        // need to care about stepColor.
                        uint8_t c = color[i];
                        c = (uint8_t) lrintf(min(255.0f, static_cast<float>(c / LightsScaleFactor)));
                        out[light*3+i] = c;
                    }
                }
            }
        }

        return result;
    }

    // State for both animations on each panel:
    AnimationState animations[NUM_SMX_LightsType][9];
};

namespace
{
    // Animations and animation states for both pads.
    AnimationStateForPad pad_states[2];
}

namespace {
    // The X,Y positions of each possible panel.
    vector<pair<int,int>> graphic_positions = {
        { 0,0 },
        { 1,0 },
        { 2,0 },
        { 0,1 },
        { 1,1 },
        { 2,1 },
        { 0,2 },
        { 1,2 },
        { 2,2 },
    };

    // Given a 14x15 graphic frame and a panel number, return an array of 16 colors, containing
    // each light in the order it's sent to the master controller.
    void ConvertToPanelGraphic16(const SMXGif::GIFImage &src, vector<SMXGif::Color> &dst, int panel)
    {
        dst.clear();

        // The top-left corner for this panel:
        int x = graphic_positions[panel].first * 5;
        int y = graphic_positions[panel].second * 5;

        // Add the 4x4 grid.
        for(int dy = 0; dy < 4; ++dy)
            for(int dx = 0; dx < 4; ++dx)
                dst.push_back(src.get(x+dx, y+dy));

        // These animations have no data for the 3x3 grid, so just set them to transparent.
        for(int dy = 0; dy < 3; ++dy)
            for(int dx = 0; dx < 3; ++dx)
                dst.push_back(SMXGif::Color(0,0,0,0));
    }

    // Given a 23x24 graphic frame and a panel number, return an array of 25 colors, containing
    // each light in the order it's sent to the master controller.
    void ConvertToPanelGraphic25(const SMXGif::GIFImage &src, vector<SMXGif::Color> &dst, int panel)
    {
        dst.clear();

        // The top-left corner for this panel:
        int x = graphic_positions[panel].first * 8;
        int y = graphic_positions[panel].second * 8;

        // Add the 4x4 grid first.
        for(int dy = 0; dy < 4; ++dy)
            for(int dx = 0; dx < 4; ++dx)
                dst.push_back(src.get(x+dx*2, y+dy*2));

        // Add the 3x3 grid.
        for(int dy = 0; dy < 3; ++dy)
            for(int dx = 0; dx < 3; ++dx)
                dst.push_back(src.get(x+dx*2+1, y+dy*2+1));
    }
}

// Load an array of animation frames as a panel animation.  Each frame must
// be 14x15 or 23x24.
void SMXPanelAnimation::Load(const vector<SMXGif::SMXGifFrame> &frames, int panel)
{
    m_aPanelGraphics.clear();
    m_iFrameDurations.clear();
    m_iLoopFrame = -1;

    for(size_t frame_no = 0; frame_no < frames.size(); ++frame_no)
    {
        const SMXGif::SMXGifFrame &gif_frame = frames[frame_no];

        // If the bottom-left pixel is white, this is the loop frame, which marks the
        // frame the animation should start at after a loop.  This is global to the
        // animation, not specific to each panel.
        SMXGif::Color marker = gif_frame.frame.get(0, gif_frame.frame.height-1);
        if(marker.color[3] == 0xFF && marker.color[0] >= 0x80)
        {
            // We shouldn't see more than one of these.  If we do, use the first.
            if(m_iLoopFrame == -1)
                m_iLoopFrame = frame_no;
        }

        // Extract this frame.  If the graphic is 14x15 it's a 4x4 animation,
        // and if it's 23x24 it's 25-light.
        vector<SMXGif::Color> panel_graphic;
        if(frames[0].width == 14)
            ConvertToPanelGraphic16(gif_frame.frame, panel_graphic, panel);
        else
            ConvertToPanelGraphic25(gif_frame.frame, panel_graphic, panel);

        // GIFs have a very low-resolution duration field, with 10ms units.
        // The panels run at 30 FPS internally, or 33 1/3 ms, but GIF can only
        // represent 30ms or 40ms.  Most applications will probably output 30,
        // but snap both 30ms and 40ms to exactly 30 FPS to make sure animations
        // that are meant to run at native framerate do.
        float seconds;
        if(gif_frame.milliseconds == 30 || gif_frame.milliseconds == 40)
            seconds = 1 / 30.0f;
        else
            seconds = gif_frame.milliseconds / 1000.0;

        m_aPanelGraphics.push_back(panel_graphic);
        m_iFrameDurations.push_back(seconds);
    }

    // By default, loop back to the first frame.
    if(m_iLoopFrame == -1)
        m_iLoopFrame = 0;
}

#include "SMXPanelAnimationUpload.h"

// Load a GIF into SMXLoadedPanelAnimations::animations.
bool SMX_LightsAnimation_Load(const char *gif, int size, int pad, SMX_LightsType type, const char **error)
{
    // Parse the GIF.
    string buf(gif, size);
    vector<SMXGif::SMXGifFrame> frames;
    if(!SMXGif::DecodeGIF(buf, frames) || frames.empty())
    {
        *error = "The GIF couldn't be read.";
        return false;
    }

    // Check the dimensions of the image.  We only need to check the first, the
    // others will always have the same size.
    if((frames[0].width != 14 || frames[0].height != 15) && (frames[0].width != 23 || frames[0].height != 24))
    {
        *error = "The GIF must be 14x15 or 23x24.";
        return false;
    }

    // Load the graphics into SMXPanelAnimations.
    SMXPanelAnimation animations[9];
    for(int panel = 0; panel < 9; ++panel)
        animations[panel].Load(frames, panel);

    // Set up the upload for this graphic.
    if(!SMX_LightsUpload_PrepareUpload(pad, type, animations, error))
        return false;

    // Lock while we access pad_states.
    g_Lock.AssertNotLockedByCurrentThread();
    LockMutex L(g_Lock);

    // Commit the animation to pad_states now that we know there are no errors.
    for(int panel = 0; panel < 9; ++panel)
    {
        SMXPanelAnimation &animation = pad_states[pad].animations[type][panel].animation;
        animation = animations[panel];
    }

    return true;
}

namespace
{
    double g_fStopAnimatingUntil = -1;
}

void SMXAutoPanelAnimations::TemporaryStopAnimating()
{
    // Stop animating for 100ms.
    double fStopForSeconds = 1/10.0f;
    g_fStopAnimatingUntil = SMX::GetMonotonicTime() + fStopForSeconds;
}

// A thread to handle setting light animations.  We do this in a separate
// thread rather than in the SMXManager thread so this can be treated as
// if it's external application thread, and it's making normal threaded
// calls to SetLights.
class PanelAnimationThread: public SMXThread
{
public:
    static shared_ptr<PanelAnimationThread> g_pSingleton;
    PanelAnimationThread():
        SMXThread(g_Lock)
    {
        Start("SMX light animations");
    }

private:
    void ThreadMain()
    {
        m_Lock.Lock();
        
        // Update lights at 30 FPS.
        const int iDelayMS = 33;

        while(!m_bShutdown)
        {
            // Check if we've temporarily stopped updating lights.
            bool bSkipUpdate = g_fStopAnimatingUntil > SMX::GetMonotonicTime();

            // Run a single panel lights update.
            if(!bSkipUpdate)
                UpdateLights();

            // Wait up to 30 FPS, or until we're signalled.  We can only be signalled
            // if we're shutting down, so we don't need to worry about partial frame
            // delays.
            m_Event.Wait(iDelayMS);
        }

        m_Lock.Unlock();
    }

    // Return lights for the given pad and pad state, using the loaded panel animations.
    bool GetCurrentLights(string &asLightsDataOut, int pad, int iPadState)
    {
        m_Lock.AssertLockedByCurrentThread();

        // Get this pad's configuration.
        SMXConfig config;
        if(!SMXManager::g_pSMX->GetDevice(pad)->GetConfig(config))
            return false;

        // If this controller handles animation itself, don't handle it here too.  It can
        // lead to confusing situations if SMXConfig's animations don't match the ones stored
        // on the pad.
        if(config.masterVersion >= 4)
            return false;

        AnimationStateForPad &pad_state = pad_states[pad];

        // Make sure the correct animations are playing.
        for(int panel = 0; panel < 9; ++panel)
        {
            // The released animation is always playing.
            pad_state.animations[SMX_LightsType_Released][panel].Play();

            // The pressed animation only plays while the button is pressed,
            // and rewind when it's released.
            bool bPressed = iPadState & (1 << panel);
            if(bPressed)
                pad_state.animations[SMX_LightsType_Pressed][panel].Play();
            else
                pad_state.animations[SMX_LightsType_Pressed][panel].Stop();
        }

        // Set the current state.
        asLightsDataOut = pad_state.GetLightsCommand(iPadState, config);

        // Advance animations.
        for(int type = 0; type < NUM_SMX_LightsType; ++type)
        {
            for(int panel = 0; panel < 9; ++panel)
                pad_state.animations[type][panel].Update();
        }

        return true;
    }

    // Run a single light animation update.
    void UpdateLights()
    {
        string asLightsData[2];
        bool bHaveLights = false;
        for(int pad = 0; pad < 2; pad++)
        {
            int iPadState = SMXManager::g_pSMX->GetDevice(pad)->GetInputState();
            if(GetCurrentLights(asLightsData[pad], pad, iPadState))
                bHaveLights = true;
        }

        // Update lights.
        if(bHaveLights)
            SMXManager::g_pSMX->SetLights(asLightsData);
    }
};

void SMX_LightsAnimation_SetAuto(bool enable)
{
    if(!enable)
    {
        // If we're turning off, shut down the thread if it's running.
        if(PanelAnimationThread::g_pSingleton)
            PanelAnimationThread::g_pSingleton->Shutdown();
        PanelAnimationThread::g_pSingleton.reset();
        return;
    }

    // Create the animation thread if it's not already running.
    if(PanelAnimationThread::g_pSingleton)
        return;
    PanelAnimationThread::g_pSingleton.reset(new PanelAnimationThread());
}

shared_ptr<PanelAnimationThread> PanelAnimationThread::g_pSingleton;