#pragma once

#include "defines.hpp"
#include "events/Events.hpp"
#include "helpers/SubsurfaceTree.hpp"
#include "helpers/AnimatedVariable.hpp"
#include "render/decorations/IHyprWindowDecoration.hpp"
#include <deque>
#include "config/ConfigDataValues.hpp"

enum eIdleInhibitMode
{
    IDLEINHIBIT_NONE = 0,
    IDLEINHIBIT_ALWAYS,
    IDLEINHIBIT_FULLSCREEN,
    IDLEINHIBIT_FOCUS
};

struct SWindowSpecialRenderData {
    bool    alphaOverride         = false;
    float   alpha                 = 1.f;
    bool    alphaInactiveOverride = false;
    float   alphaInactive         = -1.f; // -1 means unset

    int64_t activeBorderColor   = -1; // -1 means unset
    int64_t inactiveBorderColor = -1; // -1 means unset

    // set by the layout
    bool    rounding = true;
    bool    border   = true;
    bool    decorate = true;
};

struct SWindowAdditionalConfigData {
    std::string animationStyle       = "";
    int         rounding             = -1; // -1 means no
    bool        forceNoBlur          = false;
    bool        forceOpaque          = false;
    bool        forceOpaqueOverriden = false; // if true, a rule will not change the forceOpaque state. This is for the force opaque dispatcher.
    bool        forceAllowsInput     = false;
    bool        forceNoAnims         = false;
    bool        forceNoBorder        = false;
    bool        forceNoShadow        = false;
    bool        windowDanceCompat    = false;
    bool        noMaxSize            = false;
};

struct SWindowRule {
    std::string szRule;
    std::string szValue;

    bool        v2 = false;
    std::string szTitle;
    std::string szClass;
    int         bX11        = -1; // -1 means "ANY"
    int         bFloating   = -1;
    int         bFullscreen = -1;
    int         bPinned     = -1;
};

class CWindow {
  public:
    CWindow();
    ~CWindow();

    DYNLISTENER(commitWindow);
    DYNLISTENER(mapWindow);
    DYNLISTENER(unmapWindow);
    DYNLISTENER(destroyWindow);
    DYNLISTENER(setTitleWindow);
    DYNLISTENER(setGeometryX11U);
    DYNLISTENER(fullscreenWindow);
    DYNLISTENER(newPopupXDG);
    DYNLISTENER(requestMove);
    DYNLISTENER(requestMinimize);
    DYNLISTENER(requestMaximize);
    DYNLISTENER(requestResize);
    DYNLISTENER(activateX11);
    DYNLISTENER(configureX11);
    DYNLISTENER(toplevelClose);
    DYNLISTENER(toplevelActivate);
    DYNLISTENER(toplevelFullscreen);
    // DYNLISTENER(newSubsurfaceWindow);

    union {
        wlr_xdg_surface*      xdg;
        wlr_xwayland_surface* xwayland;
    } m_uSurface;

    // this is the position and size of the "bounding box"
    Vector2D                                           m_vPosition = Vector2D(0, 0);
    Vector2D                                           m_vSize     = Vector2D(0, 0);

    // this is the real position and size used to draw the thing
    CAnimatedVariable                                  m_vRealPosition;
    CAnimatedVariable                                  m_vRealSize;

    // for not spamming the protocols
    Vector2D                                           m_vReportedPosition;
    Vector2D                                           m_vReportedSize;

    // for restoring floating statuses
    Vector2D                                           m_vLastFloatingSize;
    Vector2D                                           m_vLastFloatingPosition;

    // this is used for pseudotiling
    bool                                               m_bIsPseudotiled = false;
    Vector2D                                           m_vPseudoSize    = Vector2D(0, 0);

    uint64_t                                           m_iTags          = 0;
    bool                                               m_bIsFloating    = false;
    bool                                               m_bDraggingTiled = false; // for dragging around tiled windows
    bool                                               m_bIsFullscreen  = false;
    uint64_t                                           m_iMonitorID     = -1;
    std::string                                        m_szTitle        = "";
    int                                                m_iWorkspaceID   = -1;

    bool                                               m_bIsMapped = false;

    bool                                               m_bRequestsFloat = false;

    // This is for fullscreen apps
    bool                                               m_bCreatedOverFullscreen = false;

    // XWayland stuff
    bool                                               m_bIsX11                = false;
    bool                                               m_bMappedX11            = false;
    CWindow*                                           m_pX11Parent            = nullptr;
    uint64_t                                           m_iX11Type              = 0;
    bool                                               m_bIsModal              = false;
    bool                                               m_bX11DoesntWantBorders = false;
    bool                                               m_bX11ShouldntFocus     = false;
    //

    // For nofocus
    bool                                               m_bNoFocus        = false;
    bool                                               m_bNoInitialFocus = false;

    // initial fullscreen and fullscreen disabled
    bool                                               m_bWantsInitialFullscreen = false;
    bool                                               m_bNoFullscreenRequest    = false;

    SSurfaceTreeNode*                                  m_pSurfaceTree = nullptr;

    // Animated border
    CGradientValueData                                 m_cRealBorderColor         = {0};
    CGradientValueData                                 m_cRealBorderColorPrevious = {0};
    CAnimatedVariable                                  m_fBorderAnimationProgress;

    // Fade in-out
    CAnimatedVariable                                  m_fAlpha;
    bool                                               m_bFadingOut     = false;
    bool                                               m_bReadyToDelete = false;
    Vector2D                                           m_vOriginalClosedPos;  // these will be used for calculations later on in
    Vector2D                                           m_vOriginalClosedSize; // drawing the closing animations

    // For pinned (sticky) windows
    bool                                               m_bPinned = false;

    // for proper cycling. While cycling we can't just move the pointers, so we need to keep track of the last cycled window.
    CWindow*                                           m_pLastCycledWindow = nullptr;

    // Foreign Toplevel proto
    wlr_foreign_toplevel_handle_v1*                    m_phForeignToplevel = nullptr;

    // Window decorations
    std::deque<std::unique_ptr<IHyprWindowDecoration>> m_dWindowDecorations;
    std::vector<IHyprWindowDecoration*>                m_vDecosToRemove;

    // Special render data, rules, etc
    SWindowSpecialRenderData                           m_sSpecialRenderData;
    SWindowAdditionalConfigData                        m_sAdditionalConfigData;

    // for alpha
    CAnimatedVariable                                  m_fActiveInactiveAlpha;

    // animated shadow color
    CAnimatedVariable                                  m_cRealShadowColor;

    // animated tint
    CAnimatedVariable                                  m_fDimPercent;

    // swallowing
    CWindow*                                           m_pSwallowed = nullptr;

    // for toplevel monitor events
    uint64_t                                           m_iLastToplevelMonitorID = -1;
    uint64_t                                           m_iLastSurfaceMonitorID  = -1;

    // for idle inhibiting windows
    eIdleInhibitMode                                   m_eIdleInhibitMode = IDLEINHIBIT_NONE;

    // For the list lookup
    bool                                               operator==(const CWindow& rhs) {
        return m_uSurface.xdg == rhs.m_uSurface.xdg && m_uSurface.xwayland == rhs.m_uSurface.xwayland && m_vPosition == rhs.m_vPosition && m_vSize == rhs.m_vSize &&
            m_bFadingOut == rhs.m_bFadingOut;
    }

    // methods
    wlr_box                getFullWindowBoundingBox();
    wlr_box                getWindowIdealBoundingBoxIgnoreReserved();
    void                   updateWindowDecos();
    pid_t                  getPID();
    IHyprWindowDecoration* getDecorationByType(eDecorationType);
    void                   removeDecorationByType(eDecorationType);
    void                   createToplevelHandle();
    void                   destroyToplevelHandle();
    void                   updateToplevel();
    void                   updateSurfaceOutputs();
    void                   moveToWorkspace(int);
    CWindow*               X11TransientFor();
    void                   onUnmap();
    void                   onMap();
    void                   setHidden(bool hidden);
    bool                   isHidden();
    void                   applyDynamicRule(const SWindowRule& r);
    void                   updateDynamicRules();

  private:
    // For hidden windows and stuff
    bool m_bHidden = false;
};