passepartout-apple/Passepartout/App/iOS/Scenes/ServerNetworkViewController.swift

//
//  ServerNetworkViewController.swift
//  Passepartout
//
//  Created by Davide De Rosa on 10/23/19.
//  Copyright (c) 2021 Davide De Rosa. All rights reserved.
//
//  https://github.com/passepartoutvpn
//
//  This file is part of Passepartout.
//
//  Passepartout is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  Passepartout is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with Passepartout.  If not, see <http://www.gnu.org/licenses/>.
//

import UIKit
import TunnelKit
import SwiftyBeaver
import PassepartoutCore
import Convenience

private let log = SwiftyBeaver.self

class ServerNetworkViewController: UITableViewController, StrongTableHost {
    var configuration: OpenVPN.Configuration!
    
    private let indexOfFirstRoute4 = 2

    private let indexOfFirstRoute6 = 2

    private var indexOfFirstDNSAddress = 0

    private var indexOfFirstProxyBypassDomain = 0

    // MARK: StrongTableHost

    lazy var model: StrongTableModel<SectionType, RowType> = {
        let model: StrongTableModel<SectionType, RowType> = StrongTableModel()
        var rows: [RowType]

        if let ipv4 = configuration.ipv4 {
            model.add(.ipv4)
            rows = [.address, .defaultGateway]
            for i in 0..<ipv4.routes.count {
                rows.append(.route)
            }
            model.set(rows, forSection: .ipv4)
        }

        if let ipv6 = configuration.ipv6 {
            model.add(.ipv6)
            rows = [.address, .defaultGateway]
            for i in 0..<ipv6.routes.count {
                rows.append(.route)
            }
            model.set(rows, forSection: .ipv6)
        }

        rows = []
        if let dnsDomains = configuration.searchDomains, !dnsDomains.isEmpty {
            for i in 0..<dnsDomains.count {
                rows.append(.dnsDomain)
            }
        }
        if let dnsServers = configuration.dnsServers, !dnsServers.isEmpty {
            indexOfFirstDNSAddress = rows.count
            for i in 0..<dnsServers.count {
                rows.append(.dnsAddress)
            }
        }
        if !rows.isEmpty {
            model.add(.dns)
            model.set(rows, forSection: .dns)
        }

        if let proxy = configuration.httpsProxy ?? configuration.httpProxy {
            model.add(.proxy)
            var rows: [RowType] = []
            rows.append(.proxyAddress)
            if let autoConfigurationURL = configuration.proxyAutoConfigurationURL {
                rows.append(.proxyAutoConfigurationURL)
            }
            indexOfFirstProxyBypassDomain = rows.count
            if let bypassDomains = configuration.proxyBypassDomains, !bypassDomains.isEmpty {
                for i in 0..<bypassDomains.count {
                    rows.append(.proxyBypassDomains)
                }
            }
            model.set(rows, forSection: .proxy)
        }

        // headers
        model.setHeader("IPv4", forSection: .ipv4)
        model.setHeader("IPv6", forSection: .ipv6)
        model.setHeader(L10n.Core.NetworkSettings.Dns.title, forSection: .dns)
        model.setHeader(L10n.Core.NetworkSettings.Proxy.title, forSection: .proxy)

        return model
    }()
    
    func reloadModel() {
    }
    
    // MARK: UIViewController

    override func viewDidLoad() {
        super.viewDidLoad()
        
        guard let _ = configuration else {
            fatalError("Configuration not set")
        }
    }
}

// MARK: -

extension ServerNetworkViewController {
    enum SectionType: Int {
        case ipv4

        case ipv6

        case dns
        
        case proxy
    }
    
    enum RowType: Int {
        case address
        
        case defaultGateway

        case route
        
        case dnsAddress
        
        case dnsDomain
        
        case proxyAddress

        case proxyBypassDomains

        case proxyAutoConfigurationURL
    }
    
    override func numberOfSections(in tableView: UITableView) -> Int {
        return model.numberOfSections
    }
    
    override func tableView(_ tableView: UITableView, titleForHeaderInSection section: Int) -> String? {
        return model.header(forSection: section)
    }

    override func tableView(_ tableView: UITableView, titleForFooterInSection section: Int) -> String? {
        return model.footer(forSection: section)
    }

    override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return model.numberOfRows(forSection: section)
    }

    override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let section = model.section(forIndex: indexPath.section)
        let row = model.row(at: indexPath)

        let cell = Cells.setting.dequeue(from: tableView, for: indexPath)
        cell.accessoryType = .none
        cell.isTappable = false

        // family-specific rows
        switch section {
        case .ipv4:
            switch row {
            case .address:
                cell.leftText = L10n.Core.Global.Captions.address
                if let ipv4 = configuration.ipv4 {
                    cell.rightText = "\(ipv4.address)/\(ipv4.addressMask)"
                } else {
                    cell.rightText = L10n.Core.Global.Values.none
                }

            case .defaultGateway:
                cell.leftText = L10n.Core.NetworkSettings.Gateway.title
                cell.rightText = configuration.ipv4?.defaultGateway ?? L10n.Core.Global.Values.none

            case .route:
                guard let route = configuration.ipv4?.routes[indexPath.row - indexOfFirstRoute4] else {
                    fatalError("Got an IPv4 route cell with empty routes")
                }
                cell.leftText = L10n.Core.ServerNetwork.Cells.Route.caption
                cell.rightText = "\(route.destination)/\(route.mask) -> \(route.gateway)"

            default:
                break
            }

        case .ipv6:
            switch row {
            case .address:
                cell.leftText = L10n.Core.Global.Captions.address
                if let ipv6 = configuration.ipv6 {
                    cell.rightText = "\(ipv6.address)/\(ipv6.addressPrefixLength)"
                } else {
                    cell.rightText = L10n.Core.Global.Values.none
                }

            case .defaultGateway:
                cell.leftText = L10n.Core.NetworkSettings.Gateway.title
                cell.rightText = configuration.ipv6?.defaultGateway ?? L10n.Core.Global.Values.none

            case .route:
                guard let route = configuration.ipv6?.routes[indexPath.row - indexOfFirstRoute6] else {
                    fatalError("Got an IPv6 route cell with empty routes")
                }
                cell.leftText = L10n.Core.ServerNetwork.Cells.Route.caption
                cell.rightText = "\(route.destination)/\(route.prefixLength) -> \(route.gateway)"

            default:
                break
            }
            
        default:
            break
        }

        // shared rows
        switch row {
        case .dnsDomain:
            guard let domain = configuration.searchDomains?[indexPath.row] else {
                fatalError("Got DNS search domain with empty search domains")
            }
            cell.leftText = L10n.Core.NetworkSettings.Dns.Cells.Domain.caption
            cell.rightText = domain
            
        case .dnsAddress:
            guard let server = configuration.dnsServers?[indexPath.row - indexOfFirstDNSAddress] else {
                fatalError("Got DNS server with empty servers")
            }
            cell.leftText = L10n.Core.Global.Captions.address
            cell.rightText = server

        case .proxyAddress:
            guard let proxy = configuration.httpsProxy ?? configuration.httpProxy else {
                fatalError("Got proxy section without a proxy")
            }
            cell.leftText = L10n.Core.Global.Captions.address
            cell.rightText = "\(proxy.address):\(proxy.port)"

        case .proxyAutoConfigurationURL:
            cell.leftText = "PAC"
            guard let url = configuration.proxyAutoConfigurationURL else {
                fatalError("Got PAC cell without a PAC")
            }
            cell.rightText = url.absoluteString

        case .proxyBypassDomains:
            guard let domain = configuration.proxyBypassDomains?[indexPath.row - indexOfFirstProxyBypassDomain] else {
                fatalError("Got proxy bypass domain with empty domains")
            }
            cell.leftText = L10n.App.NetworkSettings.Cells.ProxyBypass.caption
            cell.rightText = domain
            
        default:
            break
        }

        return cell
    }
}