{- Types to define a conky configuration.

Key terms:
- widget: the components of a module (dials, bars, plots, etc)
- module: a monitor for some aspect of the system to be displayed
- column: a vertical arrangement of modules
- panel: a horizontal arrangement of columns
- layout: a horizontal arrangement of panels
- geometry: the 'dimensions' of a widget
- pattern: the color/gradient to be used in widgets

NOTE: geometry is defined on a global level and at the module level. The global
level is defined in the theme type (see below) and applies to all widgets
equally. Some dimensions are not defined globally and are instead delegated to
each module to define themselves (these are not overrides so they must be
specified, although most modules have sensible defaults hardcoded)

See the 'fallback' config for an example of how to use these types.
-}
let Vector2 = \(a : Type) -> { x : a, y : a }

let Point = Vector2 Natural

let Margin = Vector2 Natural

let FSPath = { name : Text, path : Text }

let TextGeo =
    {-
    Defines text dimensions for multiline visuals

    text_spacing: gap between lines of text
    -}
      { Type = { text_spacing : Natural }, default.text_spacing = 20 }

let SepGeo =
    {-
    Defines separator dimensions

    sep_spacing: gap between the separator and either above or below
    -}
      { Type = { sep_spacing : Natural }, default.sep_spacing = 20 }

let PlotGeo =
    {-
    Defines plot dimensions

    sec_break: gap between the plot label and the plot itself
    height: height of the plot (without the label)
    ticks_y: number of ticks on the y axis
    -}
      { Type = { sec_break : Natural, height : Natural, ticks_y : Natural }
      , default = { sec_break = 20, height = 56, ticks_y = 4 }
      }

let PlotGeo_ = { Type = { plot : PlotGeo.Type }, default.plot = PlotGeo::{=} }

let TableGeo =
    {-
    Defines table dimensions

    sec_break: spacing between header and the first table row
    -}
      { Type = { sec_break : Natural }, default.sec_break = 20 }

let TableGeo_ =
      { Type = { table : TableGeo.Type }, default.table = TableGeo::{=} }

let FSGeo =
    {-
    Defines Filesystem module dimensions

    bar_spacing: spacing between percent usage bars
    bar_pad: spacing between usage bars and the left edge of the panel
    -}
      { Type = { bar_spacing : Natural, bar_pad : Natural } //\\ SepGeo.Type
      , default = { bar_spacing = 20, bar_pad = 100 } /\ SepGeo::{=}
      }

let GfxGeo =
    {-
    Defines Graphics module dimensions

    See PlotGeo, TextGeo, and SepGeo for options included here
    -}
      { Type = SepGeo.Type //\\ PlotGeo_.Type //\\ TextGeo.Type
      , default = SepGeo::{=} /\ PlotGeo_::{=} /\ TextGeo::{=}
      }

let MemGeo =
    {-
    Defines Memory module dimensions

    See PlotGeo, TextGeo, and TableGeo for options included here
    -}
      { Type = TextGeo.Type //\\ PlotGeo_.Type //\\ TableGeo_.Type
      , default = TextGeo::{=} /\ PlotGeo_::{=} /\ TableGeo_::{=}
      }

let ProcGeo =
    {-
    Defines Processor module dimensions

    See GfxGeo and TableGeo for options included here
    -}
      { Type = GfxGeo.Type //\\ TableGeo_.Type
      , default = GfxGeo::{=} /\ TableGeo_::{=}
      }

let PwrGeo =
    {-
    Defines Processor module dimensions

    See TextGeo and PlotGeo for options included here
    -}
      { Type = TextGeo.Type //\\ PlotGeo_.Type
      , default = TextGeo::{=} /\ PlotGeo_::{=}
      }

let AllGeo =
      { TextGeo, PlotGeo, TableGeo, FSGeo, GfxGeo, MemGeo, ProcGeo, PwrGeo }

let FileSystem =
    {-
    Defines Filesystem module configuration

    show_smart: show SMART daemon indicator
    show_seafile: show seafile daemon indicator
    fs_paths: list of filesystem paths to monitor for percent usage
    geometry: dimensional data for this module
    -}
      { Type =
          { show_smart : Bool
          , show_seafile : Bool
          , fs_paths : List FSPath
          , geometry : FSGeo.Type
          }
      , default.geometry = FSGeo::{=}
      }

let GPUPower =
    {-
    Controls how the GPU will be queries so it can go to sleep when 'idle'.

    freq_limit: only query the GPU every 'cycle_seconds' when frequency is below
                this value; this should be a sensible value representing and
                'idle' gpu state. Set to 0 to disable this check entirely.
    cycle_seconds: the number of seconds to query the GPU when below the idle
                   frequency limit; note that this must be long enough to let
                   the GPU go to sleep when it actually is ready to sleep, but
                   not so long that the next query will miss too much activity
                   in the case the GPU doesn't shut off
    -}
      { Type = { freq_limit : Natural, cycle_seconds : Natural }
      , default = { freq_limit = 250, cycle_seconds = 10 }
      }

let Graphics =
    {-
    Defines Graphics module configuration

    dev_power: show a power indicator
    show_temp: show temperature in celsius
    show_clock: show clock speed
    show_gpu_util: show percent utilization
    show_mem_util: show percent memory utilized
    show_vid_util: show percent video utilized
    geometry: dimensional configuration for this module
    -}
      { Type =
          { dev_power : Text
          , show_temp : Bool
          , show_clock : Bool
          , show_gpu_util : Bool
          , show_mem_util : Bool
          , show_vid_util : Bool
          , geometry : GfxGeo.Type
          , power : GPUPower.Type
          }
      , default = { geometry = GfxGeo::{=}, power = GPUPower::{=} }
      }

let Memory =
    {-
    Defines Memory module configuration

    show_stats: show total memory gauge, cache, buffers, shared, and slab
    show_plot: show memory utilization plot
    show_swap: show swap utilization gauge (only if 'show_stats' is true)
    table_rows: top processes by memory to display in table (max 10)
    geometry: dimensional configuration for this module
    -}
      { Type =
          { show_stats : Bool
          , show_plot : Bool
          , show_swap : Bool
          , table_rows : Natural
          , geometry : MemGeo.Type
          }
      , default.geometry = MemGeo::{=}
      }

let Network =
    {-
    Defines Network module configuration

    geometry: dimensional configuration for this module
    -}
      { Type = { geometry : PlotGeo_.Type }, default.geometry = PlotGeo_::{=} }

let CoreGroup =
    {-
    Defines a processor group for the Processor module

    threads: the number of threads for each core in this group (usually 1 or 2)
    rows: the number of rows over which to display the cores in this group
    padding: the spacing to the left and right of the gauges in this group
    -}
      { threads : Natural, rows : Natural, padding : Natural }

let Processor =
    {-
    Defines Network module configuration

    core_groups: a list of core groups to display
    show_stats: show frequency for each core group and HWP status
    show_plot: show percent utilization plot
    table_rows: top processes by cpu percent to display in table (max 10)
    geometry: dimensional configuration for this module
    -}
      { Type =
          { core_groups : List CoreGroup
          , show_stats : Bool
          , show_plot : Bool
          , table_rows : Natural
          , geometry : ProcGeo.Type
          }
      , default.geometry = ProcGeo::{=}
      }

let Pacman =
    {-
    Defines Pacman module configuration

    geometry: dimensional configuration for this module
    -}
      { Type = { geometry : TextGeo.Type }, default.geometry = TextGeo::{=} }

let RaplSpec =
    {-
    Defines a RAPL endpoint to display in the Power module

    name: nice name to display above plot
    address: sysfs address to the directory containing the 'energy_uj' file
    -}
      { name : Text, address : Text }

let Power =
    {-
    Defines Power module configuration

    battery: sysfs path to the battery to display
    rapl_specs: list of RAPL endpoints to display
    geometry: dimensional configuration for this module
    -}
      { Type =
          { battery : Text, rapl_specs : List RaplSpec, geometry : PwrGeo.Type }
      , default.geometry = PwrGeo::{=}
      }

let ReadWrite =
    {-
    Defines ReadWrite module configuration

    geometry: dimensional configuration for this module
    -}
      { Type = { devices : List Text, geometry : PlotGeo_.Type }
      , default.geometry = PlotGeo_::{=}
      }

let System =
    {-
    Defines System module configuration

    geometry: dimensional configuration for this module
    -}
      Pacman

let AllModules =
      { FileSystem
      , Graphics
      , Memory
      , Network
      , Pacman
      , Power
      , Processor
      , ReadWrite
      , System
      }

let ModType =
    {- Wrapper type for each module
    -}
      < filesystem : FileSystem.Type
      | graphics : Graphics.Type
      | memory : Memory.Type
      | network : Network.Type
      | pacman : Pacman.Type
      | processor : Processor.Type
      | power : Power.Type
      | readwrite : ReadWrite.Type
      | system : System.Type
      >

let Annotated =
    {- Helper to ensure yaml is formatted in a parsable manner for union types

    The intent is to make a block like:

    parent:
      type: <constructor_name>
      data: <stuff_in_the_union_type>
    -}
      \(a : Type) -> { type : Text, data : a }

let Block =
    {- Either vertical padding or a module -}
      < Pad : Natural | Mod : Annotated ModType >

let Column_ =
    {- A column of modules to display

    blocks: a list of blocks (either padding or a module)
    width: the width of the column (and consequently everything in said column)
    -}
      { blocks : List Block, width : Natural }

let Column =
    {- Either a column with modules or padding between columns -}
      < CPad : Natural | CCol : Column_ >

let Panel_ =
    {- A panel definition.

    columns: a list of columns to show (must be at least one)
    margins: space between the panel border and the columns
    -}
      { columns : List Column, margins : Margin }

let Panel =
    {- Wrapper type for either a panel or horizontal padding between panels -}
      < PPad : Natural | PPanel : Panel_ >

let Layout =
    {- The layout of the display

    'anchor' is the coordinate of the upper-left corner, and 'panels' contains
    the specifications of each panel (ie modules to show).
    -}
      { anchor : Point, panels : List Panel }

let Sizes =
    {- The font sizes to use for various widgets

    plot_label: the text above the plot
    table: the text in a table (headers and rows)
    header: the text of each module header
    normal: all other text (excluding plot axes)
    -}
      { Type =
          { normal : Natural
          , plot_label : Natural
          , table : Natural
          , header : Natural
          }
      , default = { normal = 13, plot_label = 8, table = 11, header = 15 }
      }

let Font =
    {- A complete font specification -}
      { Type = { family : Text, sizes : Sizes.Type }
      , default = { family = "Neuropolitical", sizes = Sizes::{=} }
      }

let PlotGeometry =
    {- Global dimensions for a plot

    seconds: number of seconds to display on the x axis
    ticks_x: the number of ticks to display on the x axis
    -}
      { Type = { seconds : Natural, ticks_x : Natural }
      , default = { seconds = 90, ticks_x = 9 }
      }

let TableGeometry =
    {- Global dimensions for a table

    name_chars: the max number of characters a cell can have before being truncated
    padding: the margins between the border and the interior text
    header_padding: the distance between the header and the first row of text
    row_spacing: the distance between each row
    -}
      { Type =
          { name_chars : Natural
          , padding : Margin
          , header_padding : Natural
          , row_spacing : Natural
          }
      , default =
        { name_chars = 8
        , padding = { x = 6, y = 15 }
        , header_padding = 20
        , row_spacing = 16
        }
      }

let HeaderGeometry =
    {- Global dimensions for the header of a module

    underline_offset: distance between bottom edge of text and the line below
    padding: the distance between the underline and the first widget in the module
    -}
      { Type = { underline_offset : Natural, padding : Natural }
      , default = { underline_offset = 26, padding = 19 }
      }

let Geometry =
    {- Global config for dimensions of various widgets -}
      { Type =
          { plot : PlotGeometry.Type
          , table : TableGeometry.Type
          , header : HeaderGeometry.Type
          }
      , default =
        { plot = PlotGeometry::{=}
        , table = TableGeometry::{=}
        , header = HeaderGeometry::{=}
        }
      }

let Color =
    {- Alias for a solid color represented as a single hex number -}
      Natural

let Alpha =
    {- Alias for alpha channel as a fraction between 0 and 1 -}
      Double

let Stop =
    {- Alias for the position of a color in a gradient (between 0 and 1) -}
      Double

let StopRGB =
    {- A solid color with a position in a gradiant -}
      { color : Color, stop : Stop }

let StopRGBA =
    {- A transparent color with a position in a gradiant -}
      { color : Color, stop : Stop, alpha : Alpha }

let ColorAlpha =
    {- A solid transparent color -}
      { color : Color, alpha : Alpha }

let Pattern =
    {- Wrapper for different pattern types -}
      < RGB : Color
      | RGBA : ColorAlpha
      | GradientRGB : List StopRGB
      | GradientRGBA : List StopRGBA
      >

let annotatePattern =
    {- Helper function to ensure patterns are parsable in yaml

    This will create entries in the yaml config like:

    parent:
      type: <pattern_type>
      date:
        <field1>: ...
        <field2>: ...
    -}
      \(a : Pattern) ->
        { type = showConstructor a, data = a } : Annotated Pattern

let mod =
    {- Helper function to ensure modules are parsable in yaml

    This will create entries in the yaml config like:

    parent:
      type: <module name>
      date:
        <field1>: ...
        <field2>: ...
    -}
      \(a : ModType) -> Block.Mod { type = showConstructor a, data = a }

let APattern = Annotated Pattern

let symGradient =
    {- Make a symmetric gradient between two colors.

    c0 will be the color of either edge and c1 will be the color in the center
    -}
      \(c0 : Natural) ->
      \(c1 : Natural) ->
        annotatePattern
          ( Pattern.GradientRGB
              [ { color = c0, stop = 0.0 }
              , { color = c1, stop = 0.5 }
              , { color = c0, stop = 1.0 }
              ]
          )

let Patterns =
    {- All patterns for a given theme
    -}
      { Type =
          { header : APattern
          , panel : { bg : APattern }
          , text :
              { active : APattern, inactive : APattern, critical : APattern }
          , border : APattern
          , plot :
              { grid : APattern
              , outline : APattern
              , data : { border : APattern, fill : APattern }
              }
          , indicator :
              { bg : APattern, fg : { active : APattern, critical : APattern } }
          }
      , default =
        { header = annotatePattern (Pattern.RGB 0xefefef)
        , panel.bg
          = annotatePattern (Pattern.RGBA { color = 0x121212, alpha = 0.7 })
        , text =
          { active = annotatePattern (Pattern.RGB 0xbfe1ff)
          , inactive = annotatePattern (Pattern.RGB 0xc8c8c8)
          , critical = annotatePattern (Pattern.RGB 0xff8282)
          }
        , border = annotatePattern (Pattern.RGB 0x888888)
        , plot =
          { grid = annotatePattern (Pattern.RGB 0x666666)
          , outline = annotatePattern (Pattern.RGB 0x777777)
          , data =
            { border =
                annotatePattern
                  ( Pattern.GradientRGB
                      [ { color = 0x003f7c, stop = 0.0 }
                      , { color = 0x1e90ff, stop = 1.0 }
                      ]
                  )
            , fill =
                annotatePattern
                  ( Pattern.GradientRGBA
                      [ { color = 0x316ece, stop = 0.2, alpha = 0.5 }
                      , { color = 0x8cc7ff, stop = 1.0, alpha = 1.0 }
                      ]
                  )
            }
          }
        , indicator =
          { bg = symGradient 0x565656 0xbfbfbf
          , fg =
            { active = symGradient 0x316BA6 0x99CEFF
            , critical = symGradient 0xFF3333 0xFFB8B8
            }
          }
        }
      }

let Theme =
    {-
    Defines the theme for displaying the window

    font: the font to use
    geometry: the global dimensions to use for each panel and widget (for
              everything not define by individual modules)
    patterns: colors and gradient definitions
    -}
      { Type =
          { font : Font.Type
          , geometry : Geometry.Type
          , patterns : Patterns.Type
          }
      , default =
        { font = Font::{=}, geometry = Geometry::{=}, patterns = Patterns::{=} }
      }

let Bootstrap =
    {- Defines minimal options to start conky prior to calling any lua code.
    -}
      { update_interval : Natural, dimensions : Point }

let Config =
    {- Global config type -}
      { bootstrap : Bootstrap, theme : Theme.Type, layout : Layout }

let toConfig =
    {- Helper function to generate a config -}
      \(update_interval : Natural) ->
      \(width : Natural) ->
      \(height : Natural) ->
      \(theme : Theme.Type) ->
      \(layout : Layout) ->
          { bootstrap =
            { update_interval, dimensions = { x = width, y = height } }
          , theme
          , layout
          }
        : Config

in      { toConfig, Block, Column, ModType, Layout, Panel, FSPath, Theme, mod }
    /\  AllModules
    /\  AllGeo