package Bus(mkBus) 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 -> Maybe Addr
busRequestToAddr req = case req of
    BusReadRequest (ReadRequest addr _) -> addr
    BusWriteRequest (WriteRequest addr _) -> addr

mkBus :: (Addr -> Maybe Integer)
      -> Module (Bus inFlightTransactions numClients numServers)
mkBus addrToServerTranslation = do
    -- Tag engines for each client to manage transaction tags
    tagEngineByClientVec :: Vector numClients (TagEngine inFlightTransactions)
    tagEngineByClientVec <- replicateM mkTagEngine

    -- Arbitration for clients to send requests to servers
    clientArbiter :: Arbiter.Arbiter_IFC numClients
    clientArbiter <- mkArbiter False

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

    -- Queues to hold requests from clients to servers
    requestQueues :: Vector numServers (FIFOF BusRequest)
    requestQueues <- replicateM (mkSizedBypassFIFOF (valueOf inFlightTransactions))

    -- Queues to hold responses from servers to clients
    responseQueues :: Vector numClients (FIFOF (BusResponse, MkTagType inFlightTransactions))
    responseQueues <- replicateM (mkSizedBypassFIFOF (valueOf inFlightTransactions))

    -- Client interface vector
    let clients :: Vector numClients (BusClient inFlightTransactions)
        clients = genWith $ \clientIdx ->
            interface BusClient
                submitRequest req = do
                    dummyVar := (not dummyVar)
                    return 0

                consumeResponse = do
                    dummyVar := (not dummyVar)
                    let dummyResponse = BusReadResponse (Left UnMapped)
                    return (dummyResponse, 0)

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

                submitResponse (clientTag, busResponse, transactionTag) = do
                    dummyVar := (not dummyVar)

    return $
        interface Bus
            clients = clients
            servers = servers