interface HandlerRequest {
  method: string
  query: Record<string, string | string[] | undefined>
  body?: Record<string, unknown>
  params?: Record<string, string>
  headers: Record<string, string>
}

interface HandlerResponse {
  statusCode: number
  setBody: (data: Record<string, unknown>) => void
  setHeader: (name: string, value: string) => void
}

export default async function handler(
  request: HandlerRequest,
  response: HandlerResponse
): Promise<void> {
  try {
    // Check if Google Sheets is connected
    if (!$google) {
      response.statusCode = 424
      response.setBody({
        success: false,
        error: 'Google Sheets is not connected.'
      })
      return
    }

    const spreadsheetId = $kv.get('google.spreadsheetId', '')
    if (!spreadsheetId) {
      response.statusCode = 500
      response.setBody({
        success: false,
        error: 'Spreadsheet not configured. Run init first.'
      })
      return
    }

    const sheets = $google.sheets({ version: 'v4' })

    if (request.method === 'GET') {
      // Fetch all expenses
      const sheetData = await sheets.spreadsheets.values.get({
        spreadsheetId,
        range: 'Sheet1!A2:G1000'
      })

      const rows = sheetData.data.values || []
      const expenses = rows.map((row) => ({
        date: row[0] || '',
        vendor: row[1] || '',
        amount: row[2] ? parseFloat(row[2]) : 0,
        category: row[3] || '',
        paymentMethod: row[4] || '',
        paid: row[5] === 'Yes',
        description: row[6] || ''
      }))

      response.setBody({
        success: true,
        data: expenses,
        count: expenses.length
      })
      return
    }

    if (request.method === 'POST') {
      // Add new expense
      const body = request.body as Record<string, unknown> | undefined

      if (!body || typeof body !== 'object') {
        response.statusCode = 400
        response.setBody({
          success: false,
          error: 'Request body must be a JSON object'
        })
        return
      }

      // Validate required fields
      if (!body.date || typeof body.date !== 'string') {
        response.statusCode = 400
        response.setBody({
          success: false,
          error: 'date is required and must be a string'
        })
        return
      }

      if (typeof body.amount !== 'number' || body.amount < 0) {
        response.statusCode = 400
        response.setBody({
          success: false,
          error: 'amount is required and must be a non-negative number'
        })
        return
      }

      // Prepare row data
      const newRow = [
        body.date,
        body.vendor || '',
        body.amount,
        body.category || '',
        body.paymentMethod || '',
        body.paid === true ? 'Yes' : 'No',
        body.description || ''
      ]

      // Append to sheet
      await sheets.spreadsheets.values.append({
        spreadsheetId,
        range: 'Sheet1!A:G',
        valueInputOption: 'USER_ENTERED',
        insertDataOption: 'INSERT_ROWS',
        requestBody: {
          values: [newRow]
        }
      })

      response.statusCode = 201
      response.setBody({
        success: true,
        message: 'Expense added successfully'
      })
      return
    }

    response.statusCode = 405
    response.setBody({
      success: false,
      error: 'Method not allowed'
    })
  } catch (error) {
    const errorMessage = error instanceof Error ? error.message : String(error)
    console.error('Expenses handler error:', errorMessage)
    response.statusCode = 500
    response.setBody({
      success: false,
      error: errorMessage
    })
  }
}