PUSHS "Printer Variables", WRAM0[PRINTER_VARS_START]
vTooBusyForPrinter: db ; one if we're too busy to use the async thread for printer stuff
vPrinterState: db ; options: NONE, READY, ERROR, FULL, PRINTING
def PS_NONE equ 0
def PS_READY equ 1
def PS_ERROR equ 2
def PS_FULL equ 3
def PS_PRINTING equ 4
vPrinterReturnValue: dw
vPrinterReturnValuePrevious: dw
vPrinterReturnValueChanged: db
vBuildingByte: dw
vPrinterIsReady: db

vPrinterRow: db
vPrinterStart: db
POPS

CheckForPrinter:
  ld a, $F
  ld hl, ZEROES
  ld bc, 0
  call SendPacket
  ret

UpdatePrintUI:
  ld a, [vPrinterState]

  cp a, PS_NONE
  ld hl, BanishPrinterUI
  jp z, Async_Spawn_HL

  cp a, PS_READY
  ld hl, SummonPrinterUI
  jp z, Async_Spawn_HL
  
  cp a, PS_ERROR
  ld hl, ShowErrorUI
  jp z, Async_Spawn_HL

  cp a, PS_PRINTING
  ld hl, ShowPrinting
  jp z, Async_Spawn_HL

  cp a, PS_FULL
  ld hl, ShowFull
  jp z, Async_Spawn_HL
  
  ld hl, BanishPrinterUI
  jp Async_Spawn_HL
  
UpdatePrintUIImmediate:
  ld a, [vPrinterReturnValue]
  cp a, $81
  call z, SummonPrinterUI
  
  ld a, [vPrinterReturnValue]
  cp a, $81
  call nz, BanishPrinterUI
  ret

BanishPrinterUI:
  ld hl, PrinterNotDetected
  ld de, _SCRN0 + 32*1 + 17
  ld b, 2
  ld c, 2
  call CopyTilesToMap
  ret
ShowErrorUI:
  ld hl, PrinterError
  ld de, _SCRN0 + 32*1 + 17
  ld b, 2
  ld c, 2 
  call CopyTilesToMap
  ret
ShowPrinting:
  ld hl, PrinterPrinting
  ld de, _SCRN0 + 32*1 + 17
  ld b, 2
  ld c, 2 
  call CopyTilesToMap
  ret
ShowFull:
  ld hl, PrinterFull
  ld de, _SCRN0 + 32*1 + 17
  ld b, 2
  ld c, 2 
  call CopyTilesToMap
  ret
SummonPrinterUI:
  ld hl, PrinterAvailable
  ld de, _SCRN0 + 32*1 + 17
  ld b, 2
  ld c, 2
  call CopyTilesToMap
  ret


SendPacket:
  ; a should be the command byte
  ; hl shoulld point at data to send
  ; bc should be the length of data
  ; squashes de for the checksum.
  push af
  
  ld a, $88
  call SendByte
  ld a, $33
  call SendByte
  pop af
  ld d, 0
  ld e, a ; the checksum always starts with a vallue of whatever the command is 
  call SendByte
  ld a, $00 
  call SendByte
  ld a, c 
  call SendByte
  ld a, b
  call SendByte
  
  ld a, e
  add a, b
  ld e, a 
  ld a, d
  adc a, 0
  ld d, a 
  
  ld a, e
  add a, c 
  ld e, a 
  ld a, d 
  adc a, 0
  ld d, a
  
  ld a, b
  or a, c 
  jp z, .doneWithByteLoop
.byteLoop
  ld a, [hl]
  add a, e
  ld e, a 
  ld a, d
  adc a, 0
  ld d, a 
  
  ld a, [hl+]
  call SendByte
  dec bc
  ld a, b
  or a, c 
  jp nz, .byteLoop
.doneWithByteLoop
  
  ld a, e
  call SendByte
  
  ld a, d
  call SendByte
  
  ld a, $00
  call SendByte
  ld [vPrinterReturnValue], a 

  ld a, $00
  call SendByte
  ld [vPrinterReturnValue+1], a 
  
  call UpdatePrinterStatus
  ret

UpdatePrinterStatus:
;vPrinterState: db ; options: NONE, READY, ERROR, FULL, PRINTING
  ld a, PS_NONE
  ld [vPrinterState], a 
  ld a, [vPrinterReturnValue]
  cp a, $81
  ret nz ; if the alive byte isn't $81, return with PS_NONE
  
  ld a, PS_ERROR
  ld [vPrinterState], a 
  ld a, [vPrinterReturnValue+1]
  and a, $F0
  ret nz ; if the top nibble is non-zero, there's some error
  
  ld a, PS_FULL
  ld [vPrinterState], a 
  ld a, [vPrinterReturnValue+1]
  bit 2, a 
  ret nz ; if the FULL bit iis set then it's full\
  
  ld a, PS_PRINTING
  ld [vPrinterState], a 
  ld a, [vPrinterReturnValue+1]
  bit 1, a 
  ret nz ; if the printing bit is set then it's printing
  
  ld a, PS_READY
  ld [vPrinterState], a 
  ret ; if we didn't find any of the bits we check for, it's good to go


PrepNetwork:
  ld a, 0 
  ld [vPrinterStart], a 
  
  ld a, $1
  ld [rSC], a 
  ret 

SendByte:
; waits until the thing is free, then sends the byte in a. puts the receiived
; byte in a anad returns.
  push af
  
  .waitForFree
    ld a, [rSC]
    bit 7, a
    jp nz, .waitForFree
  
  pop af
  ld [rSB], a
  
  ld a, 0 
  set 7, a ; request transfer 
  set 0, a ; set to leader
  ld [rSC], a 
  
  .waitForResponse
    ld a, [rSC]
    bit 7, a
    jp nz, .waitForResponse
  
  ld a, [rSB]
  ret 
  
KickOffPrintJob:
  ld a, 1 
  ld [vBlocked], a 
  
  ld a, 1
  ld [vPrinterStart],a
  ld a, 0 
  ld [vPrinterRow], a
  
  ret
  
RunPrintJob:
  ld a, [vPrinterStart]
  cp a, 0
  ret z
  
  ld a, [vPrinterRow]
  bit 0, a 
  jp z, WaitForPrintable
  
  cp a, 1
  jp nz, :+
    call PlanTopRow
    call BuildTopRow
    call DoubleTheBuffer
    call PrintTheBuffer
    ld a, [vPrinterRow]
    inc a 
    ld [vPrinterRow], a
    ret
  :
  cp a, 35
  jp z, DoBottomRow
  cp a, 37
  jp z, FinishUp
  
  call PlanRowA
  call BuildTopRow
  
  ld b, 8 ; pre-increment so that when we pre-decrement in the loop later it works
  sla a 
  sla a 
  sla a ; mullitply by 8
  add a, 24 ; offset for the border and overscan
  add a, b ; start from the bottom row of these tiles, a*8 + 7
  .addSpriteLinesLoop
    dec a 
    
    ld [vCurrentScanline], a
    call AddSpritesToLine

    dec b
    jp nz, .addSpriteLinesLoop
  .doneAddSpriteLinesLoop
  
  call DoubleTheBuffer
  call PrintTheBuffer
  ld a, [vPrinterRow]
  inc a 
  ld [vPrinterRow], a
  ret
  
PlanTopRow:
  ; draw the top of a card as tile ids in buffer one
  ld hl, CardBrowse.UITilemap
  ld bc, 10
  ld de, BUFFER_ONE
  call CopyRange ; copy tiles for the top row to the first buffer
  ld b, b
  ret
PlanRowA:
  srl a ; divide by two and subtract one to get row numbre in card space
  dec a 
  push af
  
  ld de, BUFFER_ONE
  
  ld a, $0b
  ld [de], a
  inc de

  pop af
  push af
  
  call FindCardTileMap ; now hl points at the beginning of the tile map
  sla a
  sla a
  sla a
  ld b, 0
  ld c, a ; need to advance it by a*8 bytes.
  add hl, bc
  ld b, 8
  :
    ld a, [hl+] 
    ld [de], a 
    inc de
    dec b
    jp nz, :-
  
  ld a, $0c
  ld [de], a 
  
  pop af
  
  ret
  
  
  
BuildTopRow:
  ; assuming buffer one contains a sequence of ten tile IDs
  ; this writes the tile data for each of those tiles sequentially into BUFFER_TWO
  push af
  ld hl, BUFFER_ONE
  ld de, BUFFER_TWO
  ld c, 10
  .loop
    push bc
    ld a, [hl+] ; fetch a tile ID
    push hl
    ld hl, UITiles
    cp a, 26
    jp c, :+
      ; if the tile id is greater than 26, then we need to fetch from the card data
      sub a, 26 ; and undo the offset encoded into the tile map
      call FindCardKeyTiles
    :
    call FindTileData
    ; now hl points to tile data, de points to a spot in buffer 2
    ld bc, 16
    call CopyRange
    pop hl
    pop bc
    dec c
    jp nz, .loop
  ld b, b
  pop af
  ret
DoubleTheBuffer:
  ld hl, BUFFER_TWO
  ld de, BUFFER_ONE
  
  ld a, 10
  .topHalfLoop
    push hl
    push af
    call WriteTopHalfDoubledTile
    pop af
    pop hl
    ld bc, 16
    add hl, bc
    dec a 
    jp nz, .topHalfLoop
    
  ld hl, BUFFER_TWO
  ld a, 10
  .bottomHalfLoop
    push hl
    push af
    ld bc, 8
    add hl, bc
    call WriteTopHalfDoubledTile
    pop af
    pop hl
    ld bc, 16
    add hl, bc
    dec a 
    jp nz, .bottomHalfLoop
  
  ld b, b
  ret

PrintTheBuffer:
  call ClearBuffer
  
  ld a, 4 ; fill buffer
  ld hl, BUFFER_ONE
  ld bc, $280
  call SendPacket
  
  call SendEmpty
  
  call SendPrint
  ret


WaitForPrintable:
  ld a, $F
  ld hl, ZEROES
  ld bc, 0
  call SendPacket
  
   ; NONE, READY, ERROR, FULL, PRINTING
   
  ld a, [vPrinterState]
  cp a, PS_PRINTING
  ret z
  cp a, PS_ERROR
  ret z
  cp a, PS_NONE
  ret z
  
  call ClearBuffer
  
  ld a, [vPrinterState]
  cp a, PS_FULL
  ret z
  
  ld a, [vPrinterRow]
  inc a 
  ld [vPrinterRow], a 
  
  ret
  
DoMiddleRow:
  call ClearBuffer
  ld a, [vPrinterRow]
  srl a 
  dec a 
  call SendRowA
  call SendEmpty
  call SendPrint
  ld a, [vPrinterRow]
  inc a 
  ld [vPrinterRow], a 
  ret
DoBottomRow:
  call ClearBuffer
  call SendBottomRow
  call SendPrint
  ld a, [vPrinterRow]
  inc a 
  ld [vPrinterRow], a 
  ret
FinishUp:
  call ClearBuffer
  
  ld a, 0 
  ld [vBlocked], a 
  ld [vPrinterStart],a
  ld [vPrinterRow], a
  ld a, 1 
  ld [vPrinterIsReady], a
  
  ret
  

SendEmpty:
  ld a, 4
  ld hl, ZEROES
  ld bc, 0
  call SendPacket
  ret
  
SendBottomRow:
  ; draw the top of a card
  ld de, BUFFER_ONE
  
  ; top half of border
  ld a, $11
  ld hl, UITiles
  call FindTileData
  call WriteTopHalfDoubledTile
  
  ld c, 8
.loop
  push bc
  ld a, $0d
  ld hl, UITiles
  call FindTileData
  call WriteTopHalfDoubledTile
  pop bc
  dec c
  ld a, 0 
  or a, c
  jp nz, .loop
  
  ld a, $10
  ld hl, UITiles
  call FindTileData
  call WriteTopHalfDoubledTile
  
  ; bottom half of border
  ld a, $11
  ld hl, UITiles
  call FindTileData
  call WriteBottomHalfDoubledTile
  
  ld c, 8
.loop2
  push bc
  ld a, $0d
  ld hl, UITiles
  call FindTileData
  call WriteBottomHalfDoubledTile
  pop bc
  dec c
  jp nz, .loop2
  
  ld a, $10
  ld hl, UITiles
  call FindTileData
  call WriteBottomHalfDoubledTile
  
  ld a, 4 ; fill buffer
  ld hl, BUFFER_ONE
  ld bc, $280
  call SendPacket
  
  ret

SendTopRow:
  ; draw the top of a card
  ld de, BUFFER_ONE
  
  ; top half of border
  ld a, $0e
  ld hl, UITiles
  call FindTileData ; give it a=index into some tiles, hl=what to start from
  call WriteTopHalfDoubledTile
  
  ld c, 8
.loop
  push bc
  ld a, $0a
  ld hl, UITiles
  call FindTileData
  call WriteTopHalfDoubledTile
  pop bc
  dec c
  ld a, 0 
  or a, c
  jp nz, .loop
  
  ld a, $0f
  ld hl, UITiles
  call FindTileData
  call WriteTopHalfDoubledTile
  
  ; bottom half of border
  ld a, $0e
  ld hl, UITiles
  call FindTileData
  call WriteBottomHalfDoubledTile
  
  ld c, 8
.loop2
  push bc
  ld a, $0a
  ld hl, UITiles
  call FindTileData
  call WriteBottomHalfDoubledTile
  pop bc
  dec c
  jp nz, .loop2
  
  ld a, $0f
  ld hl, UITiles
  call FindTileData
  call WriteBottomHalfDoubledTile
  
  ld a, 4 ; fill buffer
  ld hl, BUFFER_ONE
  ld bc, $280
  call SendPacket

  ret

SendRowA:
  push af

  ld de, BUFFER_ONE
  
  ; left side border
  ld a, $0b
  ld hl, UITiles
  call FindTileData
  call WriteTopHalfDoubledTile
  
  ; find the row of tile data we're looking for
  pop af
  push af
  ; a might be from 0-16, and we needd to multiply it by 8. that should stay 
  ; within 256 tho so we can just sla three times
  call FindCardTileMap
  sla a 
  sla a
  sla a
  ld b, 0 
  ld c, a
  add hl, bc
  push hl
  ; hl now holds the row of the tile map we're interested in.
  ld c, 8
.loop
  push bc
  ld a, [hl+]
  sub a, 26 ; undo the offset normally encoded into the tile data
  push hl
  call FindCardKeyTiles
  call FindTileData
  call WriteTopHalfDoubledTile
  pop hl
  pop bc
  dec c
  jp nz, .loop
  
  ; right side border
  
  ld a, $0c
  ld hl, UITiles
  call FindTileData
  call WriteTopHalfDoubledTile
  
  ld a, $0b
  ld hl, UITiles
  call FindTileData
  call WriteBottomHalfDoubledTile
  
  pop hl 
  ld c, 8
.loop2
  push bc
  ld a, [hl+]
  sub a, 26 ; undo the offset normally encoded into the tile data
  push hl
  call FindCardKeyTiles
  call FindTileData
  call WriteBottomHalfDoubledTile
  pop hl
  pop bc
  dec c
  ld a, 0 
  or a, c
  jp nz, .loop2
  
  ld a, $0c
  ld hl, UITiles
  call FindTileData
  call WriteBottomHalfDoubledTile
  
  pop af
  ; a holds the row we're on
  ld b, 8 ; pre-increment so that when we pre-decrement in the loop later it works
  sla a 
  sla a 
  sla a ; mullitply by 8
  add a, 24 ; offset for the border and overscan
  add a, b ; start from the bottom row of these tiles, a*8 + 7
  .addSpriteLinesLoop
    dec a 
    
    ld [vCurrentScanline], a
    call AddSpritesToLine

    dec b
    jp nz, .addSpriteLinesLoop
  .doneAddSpriteLinesLoop
  
  ld a, 4 ; fill buffer
  ld hl, BUFFER_ONE
  ld bc, $280
  call SendPacket
  
  ret
  
SendPrint:
  call SendEmpty

  ld hl, BUFFER_ONE
  ld a, 1 ; number of sheets
  ld [hl+], a
  ld a, $00 ; margins
  ld [hl+], a 
  ld a, $e4 ; palette
  ld [hl+], a 
  ld a, $7f ; exposure
  ld [hl+], a 
  
  ld a, 2 ; print
  ld hl, BUFFER_ONE
  ld bc, 4
  call SendPacket
  ret
  
  
ClearBuffer:
  ld a, $1
  ld hl, ZEROES
  ld bc, 0
  call SendPacket
  
  ret
  
PrinterTiles:
	db $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00
	db $00,$1c,$00,$0e,$38,$3f,$64,$7f,$7f,$7f,$7f,$40,$7f,$40,$3f,$3f
	db $00,$00,$00,$00,$00,$00,$06,$b6,$ff,$ff,$ff,$11,$ff,$11,$fe,$fe
	db $00,$00,$00,$80,$0e,$8e,$12,$9e,$24,$bc,$38,$b8,$00,$80,$00,$00
	db $00,$00,$00,$00,$5a,$5a,$92,$92,$5a,$5a,$52,$52,$9b,$9b,$00,$00
	db $00,$00,$18,$98,$18,$98,$18,$98,$18,$98,$00,$80,$18,$98,$00,$00
	db $00,$00,$00,$00,$d8,$d8,$94,$94,$d8,$d8,$94,$94,$d2,$d2,$00,$00
	db $00,$00,$00,$80,$19,$99,$15,$95,$19,$99,$11,$91,$11,$91,$00,$00
	db $00,$00,$00,$00,$92,$92,$5a,$5a,$96,$96,$52,$52,$52,$52,$00,$00
	db $00,$00,$00,$80,$1d,$9d,$11,$91,$19,$99,$11,$91,$11,$91,$00,$00
	db $00,$00,$00,$00,$52,$52,$52,$52,$52,$52,$52,$52,$db,$db,$00,$00
PrinterTiles.End: ; $22
  
PrinterNotDetected:
  db $00, $00
  db $13, $00
PrinterAvailable:
  db $f1, $f2
	db $f3, $f4
PrinterPrinting:
  db $f1, $f2
  db $f7, $f8
PrinterError:
  db $f1, $f2
  db $f5, $f6
PrinterFull:
  db $f1, $f2
  db $f9, $fa