import Foundation
import UIKit

struct GalleryLayoutConst {
    static let spacing: CGFloat = 1
    static let rowMaximumHeight: CGFloat = 150
}

protocol GalleryLayoutDelegate: class {
    func aspectRatioForIndexPath(_ indexPath: IndexPath) -> CGFloat?
}

class GalleryLayout: UICollectionViewLayout {
    weak var delegate: GalleryLayoutDelegate?

    private var cellAttributes: [IndexPath:UICollectionViewLayoutAttributes] = [:]
    private var contentSize: CGSize = CGSize.zero

    override var collectionViewContentSize: CGSize {
        return contentSize
    }

    override func prepare() {
        guard cellAttributes.isEmpty, let collectionView = collectionView else { return }

        //Layout Attributes
        let collectionViewWidth = collectionView.bounds.size.width
        var lastY: CGFloat = 0
        var lastX: CGFloat = 0

        for section in 0..<collectionView.numberOfSections {
            for item in 0..<collectionView.numberOfItems(inSection: section) {

                let ip = IndexPath(item: item, section: section)
                let att = UICollectionViewLayoutAttributes(forCellWith: ip)

                var size: CGSize
                if let sizeFromTemp = calculatedItemSizes[ip] {
                    size = sizeFromTemp
                } else {
                    lastX = 0
                    lastY = lastY + currentRowHeight + GalleryLayoutConst.spacing
                    calculateNextRowItemsSize(startFrom: ip, cvWidth: collectionViewWidth)
                    size = calculatedItemSizes[ip] ?? CGSize(width: 50, height: 50) // ?? only
                }

                att.frame = CGRect(origin: CGPoint(x: lastX, y: lastY), size: size)
                cellAttributes[ip] = att
                lastX = lastX + size.width + GalleryLayoutConst.spacing
            }
        }
        //ContentSize
        contentSize = CGSize(width: collectionViewWidth, height: lastY + currentRowHeight)
    }

    var calculatedItemSizes: [IndexPath: CGSize] = [:]
    var currentRowHeight: CGFloat = 0

    func calculateNextRowItemsSize(startFrom indexPath: IndexPath, cvWidth: CGFloat) {

        let firstAspRat = aspectRatio(indexPath)
        let firstHeihgt = cvWidth / firstAspRat

        //when the first image occupies an entire line
        if firstHeihgt <= GalleryLayoutConst.rowMaximumHeight {
            currentRowHeight = firstHeihgt
            calculatedItemSizes[indexPath] = CGSize(width: cvWidth, height: firstHeihgt)
            return
        }

        var aspRats: [IndexPath: CGFloat] = [indexPath: firstAspRat]
        var currIndexPath = indexPath

        while true {

            guard let nextIP = nextIndexPath(indexPath: currIndexPath) else {
                //when the images have not taken the whole line, but there is no more (we stretch them to the maximum allowed height)
                currentRowHeight = GalleryLayoutConst.rowMaximumHeight
                calculateForNewHeight(newHeight: currentRowHeight, aspRats: aspRats)
                return
            }

            currIndexPath = nextIP
            aspRats[currIndexPath] = aspectRatio(currIndexPath)

            let sumAspectRatios = aspRats.values.reduce(0) {$0 + $1}
            let curNewHeight = cvWidth / sumAspectRatios

            // when the pictures have taken the whole line
            if curNewHeight <= GalleryLayoutConst.rowMaximumHeight {
                currentRowHeight = curNewHeight
                calculateForNewHeight(newHeight: curNewHeight, aspRats: aspRats)
                return
            }
        }
    }

    private func calculateForNewHeight(newHeight: CGFloat, aspRats: [IndexPath: CGFloat]) {
        for (indexPath, aspRet) in aspRats {
            let newWidth = newHeight * aspRet
            calculatedItemSizes[indexPath] = CGSize(width: newWidth, height: newHeight)
        }
    }

    private func aspectRatio(_ indexPath: IndexPath) -> CGFloat {
        return delegate?.aspectRatioForIndexPath(indexPath) ?? 1
    }

    private func nextIndexPath(indexPath: IndexPath) -> IndexPath? {
        guard let cv = collectionView else { return nil }
        let currSection = indexPath.section
        guard currSection < cv.numberOfSections else { return nil }
        let currItem = indexPath.item

        if indexPath.item < cv.numberOfItems(inSection: currSection) - 1 {
            return IndexPath(item: currItem + 1, section: currSection)
        }

        let nextSection = currSection + 1
        if nextSection < cv.numberOfSections && cv.numberOfItems(inSection: nextSection) > 0  {
            return IndexPath(item: 0, section: currSection + 1)
        }
        return nil
    }

    override func layoutAttributesForElements(in rect: CGRect) -> [UICollectionViewLayoutAttributes]? {
        var allAttributes: [UICollectionViewLayoutAttributes] = []

        for (_, attributes) in cellAttributes {
            if rect.intersects(attributes.frame) {
                allAttributes.append(attributes)
            }
        }
        return allAttributes
    }

    override func layoutAttributesForItem(at indexPath: IndexPath) -> UICollectionViewLayoutAttributes? {
        return cellAttributes[indexPath]
    }

    override func invalidateLayout() {
        super.invalidateLayout()
        calculatedItemSizes = [:]
        currentRowHeight = 0
        cellAttributes = [:]
        contentSize = CGSize.zero
    }
}