Display.h

/*
 * Copyright (c) 2021, Andreas Kling <kling@serenityos.org>
 * Copyright (c) 2023, Sam Atkins <atkinssj@serenityos.org>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#pragma once

#include <AK/Assertions.h>
#include <AK/String.h>
#include <LibWeb/CSS/Enums.h>

namespace Web::CSS {

class Display {
public:
    Display() = default;
    ~Display() = default;

    String to_string() const;

    bool operator==(Display const& other) const
    {
        if (m_type != other.m_type)
            return false;
        switch (m_type) {
        case Type::Box:
            return m_value.box == other.m_value.box;
        case Type::Internal:
            return m_value.internal == other.m_value.internal;
        case Type::OutsideAndInside:
            return m_value.outside_inside.outside == other.m_value.outside_inside.outside
                && m_value.outside_inside.inside == other.m_value.outside_inside.inside
                && m_value.outside_inside.list_item == other.m_value.outside_inside.list_item;
        }
        VERIFY_NOT_REACHED();
    }

    enum class ListItem {
        No,
        Yes,
    };

    enum class Type {
        OutsideAndInside,
        Internal,
        Box,
    };

    bool is_internal() const { return m_type == Type::Internal; }
    DisplayInternal internal() const
    {
        VERIFY(is_internal());
        return m_value.internal;
    }
    bool is_table_column() const { return is_internal() && internal() == DisplayInternal::TableColumn; }
    bool is_table_row_group() const { return is_internal() && internal() == DisplayInternal::TableRowGroup; }
    bool is_table_header_group() const { return is_internal() && internal() == DisplayInternal::TableHeaderGroup; }
    bool is_table_footer_group() const { return is_internal() && internal() == DisplayInternal::TableFooterGroup; }
    bool is_table_row() const { return is_internal() && internal() == DisplayInternal::TableRow; }
    bool is_table_cell() const { return is_internal() && internal() == DisplayInternal::TableCell; }
    bool is_table_column_group() const { return is_internal() && internal() == DisplayInternal::TableColumnGroup; }
    bool is_table_caption() const { return is_internal() && internal() == DisplayInternal::TableCaption; }

    bool is_none() const { return m_type == Type::Box && m_value.box == DisplayBox::None; }
    bool is_contents() const { return m_type == Type::Box && m_value.box == DisplayBox::Contents; }

    Type type() const { return m_type; }

    bool is_outside_and_inside() const { return m_type == Type::OutsideAndInside; }

    DisplayOutside outside() const
    {
        VERIFY(is_outside_and_inside());
        return m_value.outside_inside.outside;
    }

    bool is_block_outside() const { return is_outside_and_inside() && outside() == DisplayOutside::Block; }
    bool is_inline_outside() const { return is_outside_and_inside() && outside() == DisplayOutside::Inline; }
    bool is_inline_block() const { return is_inline_outside() && is_flow_root_inside(); }

    ListItem list_item() const
    {
        VERIFY(is_outside_and_inside());
        return m_value.outside_inside.list_item;
    }

    bool is_list_item() const { return is_outside_and_inside() && list_item() == ListItem::Yes; }

    DisplayInside inside() const
    {
        VERIFY(is_outside_and_inside());
        return m_value.outside_inside.inside;
    }

    bool is_flow_inside() const { return is_outside_and_inside() && inside() == DisplayInside::Flow; }
    bool is_flow_root_inside() const { return is_outside_and_inside() && inside() == DisplayInside::FlowRoot; }
    bool is_table_inside() const { return is_outside_and_inside() && inside() == DisplayInside::Table; }
    bool is_flex_inside() const { return is_outside_and_inside() && inside() == DisplayInside::Flex; }
    bool is_grid_inside() const { return is_outside_and_inside() && inside() == DisplayInside::Grid; }
    bool is_ruby_inside() const { return is_outside_and_inside() && inside() == DisplayInside::Ruby; }
    bool is_math_inside() const { return is_outside_and_inside() && inside() == DisplayInside::Math; }

    enum class Short {
        None,
        Contents,
        Block,
        Flow,
        FlowRoot,
        Inline,
        InlineBlock,
        RunIn,
        ListItem,
        InlineListItem,
        Flex,
        InlineFlex,
        Grid,
        InlineGrid,
        Ruby,
        Table,
        InlineTable,
        Math,
    };

    static Display from_short(Short short_)
    {
        switch (short_) {
        case Short::None:
            return Display { DisplayBox::None };
        case Short::Contents:
            return Display { DisplayBox::Contents };
        case Short::Block:
            return Display { DisplayOutside::Block, DisplayInside::Flow };
        case Short::Inline:
            return Display { DisplayOutside::Inline, DisplayInside::Flow };
        case Short::Flow:
            return Display { DisplayOutside::Block, DisplayInside::Flow };
        case Short::FlowRoot:
            return Display { DisplayOutside::Block, DisplayInside::FlowRoot };
        case Short::InlineBlock:
            return Display { DisplayOutside::Inline, DisplayInside::FlowRoot };
        case Short::RunIn:
            return Display { DisplayOutside::RunIn, DisplayInside::Flow };
        case Short::ListItem:
            return Display { DisplayOutside::Block, DisplayInside::Flow, ListItem::Yes };
        case Short::InlineListItem:
            return Display { DisplayOutside::Inline, DisplayInside::Flow, ListItem::Yes };
        case Short::Flex:
            return Display { DisplayOutside::Block, DisplayInside::Flex };
        case Short::InlineFlex:
            return Display { DisplayOutside::Inline, DisplayInside::Flex };
        case Short::Grid:
            return Display { DisplayOutside::Block, DisplayInside::Grid };
        case Short::InlineGrid:
            return Display { DisplayOutside::Inline, DisplayInside::Grid };
        case Short::Ruby:
            return Display { DisplayOutside::Inline, DisplayInside::Ruby };
        case Short::Table:
            return Display { DisplayOutside::Block, DisplayInside::Table };
        case Short::InlineTable:
            return Display { DisplayOutside::Inline, DisplayInside::Table };
        case Short::Math:
            // NOTE: The spec ( https://w3c.github.io/mathml-core/#new-display-math-value ) does not
            //       mention what the outside value for `display: math` should be.
            //       The UA stylesheet does `* { display: block math; }` so let's go with that.
            return Display { DisplayOutside::Block, DisplayInside::Math };
        }
        VERIFY_NOT_REACHED();
    }

    Display(DisplayOutside outside, DisplayInside inside)
        : m_type(Type::OutsideAndInside)
    {
        m_value.outside_inside = {
            .outside = outside,
            .inside = inside,
            .list_item = ListItem::No,
        };
    }

    Display(DisplayOutside outside, DisplayInside inside, ListItem list_item)
        : m_type(Type::OutsideAndInside)
    {
        m_value.outside_inside = {
            .outside = outside,
            .inside = inside,
            .list_item = list_item,
        };
    }

    explicit Display(DisplayInternal internal)
        : m_type(Type::Internal)
    {
        m_value.internal = internal;
    }

    explicit Display(DisplayBox box)
        : m_type(Type::Box)
    {
        m_value.box = box;
    }

private:
    Type m_type {};
    union {
        struct {
            DisplayOutside outside;
            DisplayInside inside;
            ListItem list_item;
        } outside_inside;
        DisplayInternal internal;
        DisplayBox box;
    } m_value {};
};

}