// images.js
export function processImages(config, fetch) {
  if (!fetch) {
    fetch = config
    config = undefined
  }
  return async function processImages(req, opts) {
    const url = new URL(req.url)
    const sizes = (config && config.sizes) || {}
    let width = undefined

    if (url.search) {
      const key = url.search.substring(1)
      const s = sizes[key]
      if (s && s.width) {
        width = s.width
      }
    }

    let resp = await fetch(req, opts)
    let data = await resp.arrayBuffer()
    
      if (width) {
        let image = new fly.Image(data)
        image.withoutEnlargement().resize(width)
        const result = await image.toBuffer()
        data = result.data
      }

    resp = new Response(data, resp)
    resp.headers.set('content-length', data.byteLength)
    return new Response(data, resp)
  }
}

processImages.withConfig = function withConfig(config) {
  return processImages.bind(null, config)
}

// index.js
import proxy from '@fly/proxy'
import { processImages } from './images'

const origin = proxy("https://www.example.com")
const assets = proxy("http://www.example.com/images/", { stripPath: "/images/" })

fly.http.respondWith(
  pipeline(
    responsiveImages,
    processImages.withConfig({
      sizes: {
        index: { width: 600 }
      }
    }),
    rewriteLinks,
    mount({
         "/images/": assets,
         "/": origin
    })
  )
)

const rewrites = [
     [/(https?:)?\/\/images\.example\.com/g, "/images"],
     [/https:\\u002F\\u002Fimages.example.com\\u002F/g, "\\u002Fimages\\u002F"],
]

function rewriteLinks(fetch) {
  return async function rewriteHTML(req, init) {
    req.headers.delete("accept-encoding")
    const resp = await fetch(req, init)
    if (app.env === "development") {
      resp.headers.delete("strict-transport-security")
      resp.headers.delete("content-security-policy")
    }
    const contentType = resp.headers.get("content-type") || ""
    if (
      contentType.includes("/html") ||
      contentType.includes("application/javascript") ||
      contentType.includes("application/json") ||
      contentType.includes("text/")
    ) {
      let body = await resp.text()
      for (const r of rewrites) {
        body = body.replace(r[0], r[1])
      }
      resp.headers.delete("content-length")
      return new Response(body, resp)
    }
    return resp
  }
}

function responsiveImages(fetch) {
  return async function responsiveImages(req, init) {
    if (req.method != "GET") {
      return fetch(req, init)
    }

    let resp = await fetch(req, init)
    const contentType = resp.headers.get("content-type") || ""

    if (!contentType.includes("html") || resp.status != 200) {
      return resp
    }

    resp.headers.delete("content-length")
    let body = await resp.text()
    const doc = Document.parse(body)
    const replacements = []

    for (const img of doc.querySelectorAll("img")) {
      let src = img.getAttribute("src")
      if (src) {
        replacements.push([
          src.replace(/\//g, "\\u002F"),
          src.replace(/\//g, '\\u002F') + '?index'
        ])
        img.setAttribute('src', `${src}?index`)
      }
    }

    body = doc.documentElement.outerHTML

    for (const r of replacements) {
      body = body.replace(r[0], r[1])
    }
    
    resp = new Response(body, resp)
    return resp
  }
}

function mount(paths) {
  return function mount(req, init) {
    const url = new URL(req.url)
    for (const p of Object.getOwnPropertyNames(paths)) {
      if (url.pathname.startsWith(p)) {
        return paths[p](req, init)
      }
    }
    return new Response("no mount found", { status: 404 })
  }
}

function pipeline() {
  let fn = null
  for (let i = arguments.length - 1; i >= 0; i--) {
    if (fn) {
      fn = arguments[i](fn)
    } else {
      fn = arguments[i]
    }
  }
  return fn
}