package Bus(mkBus, Bus(..)) where

import Types
import BusTypes
import TagEngine
import Vector
import Util
import Arbiter
import FIFO
import FIFOF
import SpecialFIFOs

clientRequest :: Arbiter.ArbiterClient_IFC -> Action
clientRequest ifc = ifc.request

busRequestToAddr :: BusRequest -> Addr
busRequestToAddr req = case req of
    BusReadRequest (ReadRequest addr _) -> addr
    BusWriteRequest (WriteRequest addr _) -> addr

dummyRule :: Rules
dummyRule = 
    rules
        "test rule": when True ==> do
            $display "test rule"

-- we need a way to make serverMap safer...
mkBus :: (Addr -> Maybe ServerIdx)
      -> Module (Bus inFlightTransactions numClients numServers)
mkBus serverMap = do
    -- Tag engines for each client to manage transaction tags
    tagEngineByClientVec :: Vector numClients (TagEngine inFlightTransactions)
    tagEngineByClientVec <- replicateM mkTagEngine

    -- each 
    clientArbiters :: Arbiter.Arbiter_IFC numServers
    clientArbiters <- mkArbiter False

    serverArbiters :: Arbiter.Arbiter_IFC numClients
    serverArbiters <- mkArbiter False

    dummyVar :: Reg(Bool)
    dummyVar <- mkReg False

    -- Queues to hold requests from clients
    clientRequestQueues :: Vector numClients (FIFOF (TaggedBusRequest inFlightTransactions))
    clientRequestQueues <- replicateM (mkSizedBypassFIFOF (valueOf inFlightTransactions))

    -- Queues to hold responses to clients
    clientResponseQueues :: Vector numClients (FIFOF (TaggedBusResponse inFlightTransactions))
    clientResponseQueues <- replicateM (mkSizedBypassFIFOF (valueOf inFlightTransactions))

    let clientRouter :: Vector numClients (Rules)
        clientRouter = genWith $ \clientIdx ->
            let
                selectedClientRequestQueue :: FIFOF (TaggedBusRequest inFlightTransactions)
                selectedClientRequestQueue = (select clientRequestQueues clientIdx)
            in
                rules
                    "route request": when True ==> do
                        let 
                            clientRequest :: (TaggedBusRequest inFlightTransactions)
                            clientRequest = selectedClientRequestQueue.first

                            -- targetAddr :: Addr = busRequestToAddr clientRequest
                            -- targetServerIdx :: (Maybe ServerIdx) = serverMap targetAddr
                        -- case targetServerIdx of
                        --     Just serverIdx -> do
                        --         targetServerArbiter :: 

                        $display "client test rule " (fromInteger clientIdx)

    addRules |> foldr (<+>) (rules {}) clientRouter

    addRules |>
        rules
            "test rule": when True ==> do
                $display "test rule"

    -- Client interface vector
    let clients :: Vector numClients (BusClient inFlightTransactions)
        clients = genWith $ \clientIdx ->
            let
                selectedClientRequestQueue :: FIFOF (TaggedBusRequest inFlightTransactions)
                selectedClientRequestQueue = (select clientRequestQueues clientIdx)

                selectedClientResponseQueue :: FIFOF (TaggedBusResponse inFlightTransactions)
                selectedClientResponseQueue = (select clientResponseQueues clientIdx)

                selectedTagEngine :: TagEngine inFlightTransactions
                selectedTagEngine = (select tagEngineByClientVec clientIdx)
            in
                interface BusClient
                    submitRequest   :: BusRequest
                                    -> ActionValue (MkTagType inFlightTransactions)
                    submitRequest busRequest = do
                        tag <- selectedTagEngine.requestTag
                        selectedClientRequestQueue.enq (TaggedBusRequest tag busRequest)
                        return tag

                    consumeResponse :: ActionValue (TaggedBusResponse inFlightTransactions)
                    consumeResponse = do
                        let
                            busResponse :: (TaggedBusResponse inFlightTransactions)
                            busResponse = selectedClientResponseQueue.first
                        selectedClientResponseQueue.deq
                        return busResponse

    -- Server interface vector
    let servers :: Vector numServers (BusServer inFlightTransactions numClients)
        servers = genWith $ \serverIdx ->
            interface BusServer
                consumeRequest  :: ActionValue (MkTagType inFlightTransactions, BusRequest)
                consumeRequest = do
                    dummyVar := (not dummyVar)
                    let dummyBusRequest = BusReadRequest (ReadRequest 0 SizeByte)
                    return (0, dummyBusRequest)

                submitResponse  :: ( MkClientTagType numClients,
                                    TaggedBusResponse inFlightTransactions
                                    ) -> Action
                submitResponse (clientTag, taggedBusResponse) = do
                    dummyVar := (not dummyVar)

    return $
        interface Bus
            clients = clients
            servers = servers