static let top = UIColor(red: 0.09, green: 0.20, blue: 0.58, alpha: 1)

static let bottom = UIColor(red: 0.10, green: 0.60, blue: 0.81, alpha: 1)

static let background = UIColor.white

static let card = UIColor(red: 0.13, green: 0.31, blue: 0.78, alpha: 1)

static let cardStrong = UIColor.white.withAlphaComponent(0.18)

static let dayListCard = UIColor.white

static let dayListBorder = UIColor(red: 0.86, green: 0.89, blue: 0.95, alpha: 1)

static let primaryText = UIColor.white

static let secondaryText = UIColor.white.withAlphaComponent(0.84)

static let accent = UIColor(red: 0.95, green: 0.87, blue: 0.05, alpha: 1)

static let darkText = UIColor(red: 0.10, green: 0.10, blue: 0.12, alpha: 1)

static let mutedText = UIColor(red: 0.55, green: 0.56, blue: 0.59, alpha: 1)

static let precipitationText = UIColor(red: 0.13, green: 0.55, blue: 0.98, alpha: 1)

override class var layerClass: AnyClass { CAShapeLayer.self }

private var shapeLayer: CAShapeLayer {

layer as? CAShapeLayer ?? CAShapeLayer()

}

override init(frame: CGRect) {

super.init(frame: frame)

configure()

}

required init?(coder: NSCoder) {

super.init(coder: coder)

configure()

}

override func layoutSubviews() {

super.layoutSubviews()

let radius = min(bounds.width / 2, bounds.height) - 2

let center = CGPoint(x: bounds.midX, y: bounds.maxY - 1)

let path = UIBezierPath(

arcCenter: center,

radius: radius,

startAngle: .pi,

endAngle: 0,

clockwise: true

)

shapeLayer.path = path.cgPath

}

private func configure() {

backgroundColor = .clear

shapeLayer.fillColor = UIColor.clear.cgColor

shapeLayer.strokeColor = WeatherTheme.accent.cgColor

shapeLayer.lineWidth = 3

shapeLayer.lineCap = .round

}

private let hourlyStripCollectionView: UICollectionView = {

let layout = UICollectionViewFlowLayout()

layout.scrollDirection = .horizontal

layout.minimumLineSpacing = 16

layout.minimumInteritemSpacing = 16

let collectionView = UICollectionView(frame: .zero, collectionViewLayout: layout)

collectionView.showsHorizontalScrollIndicator = false

collectionView.backgroundColor = .clear

return collectionView

}()

private let topCardView = UIView()

private let cityHeaderLabel = UILabel()

private let minMaxLabel = UILabel()

private let tempLabel = UILabel()

private let descriptionLabel = UILabel()

private let topArcView = ArcView()

private let sunriseIconView = UIImageView(image: UIImage(named: "icon_sunrise"))

private let sunriseLabel = UILabel()

private let sunsetIconView = UIImageView(image: UIImage(named: "icon_sunset"))

private let sunsetLabel = UILabel()

private let weatherIconView = UIImageView(image: UIImage(named: "icon_weather_medium"))

private let precipitationLabel = UILabel()

private let windIconView = UIImageView(image: UIImage(named: "icon_wind_alt"))

private let windLabel = UILabel()

private let humidityIconView = UIImageView(image: UIImage(named: "icon_humidity"))

private let humidityLabel = UILabel()

private let highlightDateLabel = UILabel()

private let dailyTitleLabel = UILabel()

private let activityIndicator = UIActivityIndicatorView(style: .large)

private let hourlyButton = UIButton(type: .system)

private let tableView = UITableView(frame: .zero, style: .plain)

private let viewModel: WeatherViewModelProtocol

private var daysData: [DailyForecast] = []

private var hoursData: [HourlyForecast] = []

private var stripHoursData: [HourlyForecast] = []

init(viewModel: WeatherViewModelProtocol) {

self.viewModel = viewModel

super.init(nibName: nil, bundle: nil)

}

required init?(coder: NSCoder) {

fatalError("init(coder:) has not been implemented")

}

override func viewDidLoad() {

super.viewDidLoad()

setupUI()

bindViewModel()

viewModel.viewDidLoad()

NotificationCenter.default.addObserver(

self,

selector: #selector(daysCountChanged),

name: ForecastSettings.daysChangedNotification,

object: nil

)

}

deinit {

NotificationCenter.default.removeObserver(self)

}

private func bindViewModel() {

viewModel.onUpdate = { [weak self] in

guard let self else { return }

self.activityIndicator.stopAnimating()

self.updateUI()

}

viewModel.onError = { [weak self] message in

self?.activityIndicator.stopAnimating()

self?.showError(message)

}

}

private func updateUI() {

cityHeaderLabel.text = viewModel.cityName

tempLabel.text = viewModel.temperatureText.replacingOccurrences(of: "C", with: "")

descriptionLabel.text = viewModel.descriptionText

daysData = viewModel.dailyForecast

hoursData = viewModel.hourlyForecast

stripHoursData = Array(hoursData.prefix(8))

updateWidgetSnapshot()

hourlyStripCollectionView.reloadData()

updateTopCardMeta()

tableView.reloadData()

}

private func updateWidgetSnapshot() {

guard let shared = UserDefaults(suiteName: "group.pogoda.net") else { return }

shared.set(viewModel.cityName, forKey: "widget.city")

shared.set(viewModel.descriptionText.capitalized, forKey: "widget.summary")

let tempText = viewModel.temperatureText

.replacingOccurrences(of: "°C", with: "")

.replacingOccurrences(of: "°", with: "")

let temperature = Int(tempText) ?? 0

shared.set(temperature, forKey: "widget.temperature")

shared.set("cloud.sun.fill", forKey: "widget.topIcon")

let days: [[String: Any]] = viewModel.dailyForecast.prefix(5).map { day in

let weekday = Self.widgetDayFormatter.string(from: day.date).lowercased()

return [

"weekday": weekday,

"precipitation": day.precipitationProbability,

"icon": Self.widgetSymbol(for: day.description),

"minTemp": day.minTemperature,

"maxTemp": day.maxTemperature

]

}

shared.set(days, forKey: "widget.days")

#if canImport(WidgetKit)

WidgetCenter.shared.reloadTimelines(ofKind: "PogodaWidget")

#endif

}

private static let widgetDayFormatter: DateFormatter = {

let formatter = DateFormatter()

formatter.locale = Locale(identifier: "ru_RU")

formatter.dateFormat = "EE"

return formatter

}()

private static func widgetSymbol(for description: String) -> String {

let normalized = description.lowercased()

if normalized.contains("гроз") { return "cloud.bolt.rain.fill" }

if normalized.contains("лив") || normalized.contains("дожд") { return "cloud.rain.fill" }

if normalized.contains("снег") { return "cloud.snow.fill" }

if normalized.contains("облач") { return "cloud.fill" }

return "sun.max.fill"

}

private func showError(_ message: String) {

let alert = UIAlertController(title: "Ошибка", message: message, preferredStyle: .alert)

alert.addAction(UIAlertAction(title: "OK", style: .default))

present(alert, animated: true)

}

private func setupUI() {

view.backgroundColor = WeatherTheme.background

cityHeaderLabel.font = .systemFont(ofSize: 20, weight: .semibold)

cityHeaderLabel.textColor = WeatherTheme.darkText

cityHeaderLabel.textAlignment = .center

cityHeaderLabel.translatesAutoresizingMaskIntoConstraints = false

minMaxLabel.font = .systemFont(ofSize: 16, weight: .regular)

minMaxLabel.textColor = WeatherTheme.secondaryText

minMaxLabel.textAlignment = .center

tempLabel.font = .systemFont(ofSize: 56, weight: .semibold)

tempLabel.textColor = WeatherTheme.primaryText

tempLabel.textAlignment = .center

descriptionLabel.font = .systemFont(ofSize: 14, weight: .medium)

descriptionLabel.textColor = WeatherTheme.secondaryText

descriptionLabel.textAlignment = .center

descriptionLabel.numberOfLines = 1

descriptionLabel.lineBreakMode = .byTruncatingTail

descriptionLabel.adjustsFontSizeToFitWidth = true

descriptionLabel.minimumScaleFactor = 0.8

descriptionLabel.translatesAutoresizingMaskIntoConstraints = false

[sunriseIconView, sunsetIconView, weatherIconView, windIconView, humidityIconView].forEach {

$0.contentMode = .scaleAspectFit

$0.translatesAutoresizingMaskIntoConstraints = false

}

sunriseIconView.tintColor = WeatherTheme.secondaryText

sunsetIconView.tintColor = WeatherTheme.secondaryText

[sunriseLabel, sunsetLabel, precipitationLabel, windLabel, humidityLabel].forEach {

$0.font = .systemFont(ofSize: 14, weight: .regular)

$0.textColor = WeatherTheme.secondaryText

}

precipitationLabel.font = .systemFont(ofSize: 14, weight: .semibold)

sunriseLabel.font = .systemFont(ofSize: 14, weight: .semibold)

sunsetLabel.font = .systemFont(ofSize: 14, weight: .semibold)

highlightDateLabel.font = .systemFont(ofSize: 12, weight: .semibold)

highlightDateLabel.textColor = WeatherTheme.accent

highlightDateLabel.textAlignment = .center

highlightDateLabel.translatesAutoresizingMaskIntoConstraints = false

let topStack = UIStackView(arrangedSubviews: [minMaxLabel, tempLabel, descriptionLabel])

topStack.axis = .vertical

topStack.spacing = 3

topStack.alignment = .fill

topStack.translatesAutoresizingMaskIntoConstraints = false

topCardView.translatesAutoresizingMaskIntoConstraints = false

topCardView.backgroundColor = WeatherTheme.card

topCardView.layer.cornerRadius = 5

topCardView.layer.cornerCurve = .continuous

topCardView.clipsToBounds = true

topArcView.translatesAutoresizingMaskIntoConstraints = false

let sunriseStack = makeMetaStack(iconView: sunriseIconView, textLabel: sunriseLabel)

let sunsetStack = makeMetaStack(iconView: sunsetIconView, textLabel: sunsetLabel)

let centerWeatherStack = makeMetaStack(iconView: weatherIconView, textLabel: precipitationLabel)

let centerWindStack = makeMetaStack(iconView: windIconView, textLabel: windLabel)

let centerHumidityStack = makeMetaStack(iconView: humidityIconView, textLabel: humidityLabel)

let centerMetaStack = UIStackView(arrangedSubviews: [centerWeatherStack, centerWindStack, centerHumidityStack])

centerMetaStack.axis = .horizontal

centerMetaStack.alignment = .center

centerMetaStack.spacing = 8

centerMetaStack.distribution = .equalSpacing

centerMetaStack.translatesAutoresizingMaskIntoConstraints = false

hourlyButton.setTitle("Подробнее на 24 часа", for: .normal)

hourlyButton.titleLabel?.font = .systemFont(ofSize: 17, weight: .bold)

hourlyButton.setTitleColor(.white, for: .normal)

hourlyButton.backgroundColor = UIColor(red: 0.13, green: 0.31, blue: 0.78, alpha: 1)

hourlyButton.layer.cornerRadius = 10

hourlyButton.layer.cornerCurve = .continuous

hourlyButton.contentEdgeInsets = UIEdgeInsets(top: 9, left: 18, bottom: 9, right: 18)

hourlyButton.addTarget(self, action: #selector(showHourly), for: .touchUpInside)

hourlyButton.translatesAutoresizingMaskIntoConstraints = false

dailyTitleLabel.text = "Ежедневный прогноз"

dailyTitleLabel.font = .systemFont(ofSize: 19, weight: .bold)

dailyTitleLabel.textColor = WeatherTheme.darkText

dailyTitleLabel.translatesAutoresizingMaskIntoConstraints = false

tableView.translatesAutoresizingMaskIntoConstraints = false

tableView.backgroundColor = .clear

tableView.separatorStyle = .none

tableView.dataSource = self

tableView.delegate = self

tableView.register(DailyWeatherCell.self, forCellReuseIdentifier: DailyWeatherCell.reuseID)

hourlyStripCollectionView.translatesAutoresizingMaskIntoConstraints = false

hourlyStripCollectionView.dataSource = self

hourlyStripCollectionView.delegate = self

hourlyStripCollectionView.register(HourlyStripCell.self, forCellWithReuseIdentifier: HourlyStripCell.reuseID)

activityIndicator.color = WeatherTheme.darkText

activityIndicator.startAnimating()

activityIndicator.translatesAutoresizingMaskIntoConstraints = false

view.addSubview(hourlyStripCollectionView)

view.addSubview(cityHeaderLabel)

view.addSubview(topCardView)

topCardView.addSubview(topStack)

topCardView.addSubview(topArcView)

topCardView.addSubview(sunriseStack)

topCardView.addSubview(sunsetStack)

topCardView.addSubview(centerMetaStack)

topCardView.addSubview(highlightDateLabel)

view.addSubview(hourlyButton)

view.addSubview(dailyTitleLabel)

view.addSubview(tableView)

view.addSubview(activityIndicator)

NSLayoutConstraint.activate([

cityHeaderLabel.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor, constant: 8),

cityHeaderLabel.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 16),

cityHeaderLabel.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -16),

topCardView.topAnchor.constraint(equalTo: cityHeaderLabel.bottomAnchor, constant: 10),

topCardView.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 16),

topCardView.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -15),

topCardView.heightAnchor.constraint(equalToConstant: 212),

topStack.topAnchor.constraint(equalTo: topCardView.topAnchor, constant: 30),

topStack.leadingAnchor.constraint(equalTo: topCardView.leadingAnchor, constant: 22),

topStack.trailingAnchor.constraint(equalTo: topCardView.trailingAnchor, constant: -22),

topArcView.leadingAnchor.constraint(equalTo: topCardView.leadingAnchor, constant: 33),

topArcView.trailingAnchor.constraint(equalTo: topCardView.trailingAnchor, constant: -31),

topArcView.topAnchor.constraint(equalTo: topCardView.topAnchor, constant: 17),

topArcView.heightAnchor.constraint(equalToConstant: 124),

sunriseStack.leadingAnchor.constraint(equalTo: topCardView.leadingAnchor, constant: 25),

sunriseStack.bottomAnchor.constraint(equalTo: topCardView.bottomAnchor, constant: -50),

sunriseIconView.widthAnchor.constraint(equalToConstant: 17),

sunriseIconView.heightAnchor.constraint(equalToConstant: 17),

sunsetStack.trailingAnchor.constraint(equalTo: topCardView.trailingAnchor, constant: -25),

sunsetStack.bottomAnchor.constraint(equalTo: topCardView.bottomAnchor, constant: -50),

sunsetIconView.widthAnchor.constraint(equalToConstant: 17),

sunsetIconView.heightAnchor.constraint(equalToConstant: 17),

centerMetaStack.centerXAnchor.constraint(equalTo: topCardView.centerXAnchor),

centerMetaStack.bottomAnchor.constraint(equalTo: topCardView.bottomAnchor, constant: -50),

weatherIconView.widthAnchor.constraint(equalToConstant: 16),

weatherIconView.heightAnchor.constraint(equalToConstant: 16),

windIconView.widthAnchor.constraint(equalToConstant: 16),

windIconView.heightAnchor.constraint(equalToConstant: 16),

humidityIconView.widthAnchor.constraint(equalToConstant: 16),

humidityIconView.heightAnchor.constraint(equalToConstant: 16),

highlightDateLabel.centerXAnchor.constraint(equalTo: topCardView.centerXAnchor),

highlightDateLabel.bottomAnchor.constraint(equalTo: topCardView.bottomAnchor, constant: -26),

hourlyStripCollectionView.topAnchor.constraint(equalTo: topCardView.bottomAnchor, constant: 12),

hourlyStripCollectionView.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 16),

hourlyStripCollectionView.trailingAnchor.constraint(equalTo: view.trailingAnchor),

hourlyStripCollectionView.heightAnchor.constraint(equalToConstant: 85),

hourlyButton.topAnchor.constraint(equalTo: hourlyStripCollectionView.bottomAnchor, constant: 14),

hourlyButton.centerXAnchor.constraint(equalTo: view.centerXAnchor),

dailyTitleLabel.topAnchor.constraint(equalTo: hourlyButton.bottomAnchor, constant: 10),

dailyTitleLabel.leadingAnchor.constraint(equalTo: topCardView.leadingAnchor),

tableView.topAnchor.constraint(equalTo: dailyTitleLabel.bottomAnchor, constant: 10),

tableView.leadingAnchor.constraint(equalTo: view.leadingAnchor),

tableView.trailingAnchor.constraint(equalTo: view.trailingAnchor),

tableView.bottomAnchor.constraint(equalTo: view.bottomAnchor),

activityIndicator.centerXAnchor.constraint(equalTo: view.centerXAnchor),

activityIndicator.centerYAnchor.constraint(equalTo: view.centerYAnchor)

])

}

private func updateTopCardMeta() {

let today = daysData.first

if let today {

minMaxLabel.text = "\(today.minTemperature)°/\(today.maxTemperature)°"

sunriseLabel.text = Self.timeFormatter.string(from: today.sunrise ?? today.date)

sunsetLabel.text = Self.timeFormatter.string(from: today.sunset ?? today.date)

precipitationLabel.text = "\(today.precipitationProbability)"

windLabel.text = Self.windFormatter.string(from: NSNumber(value: today.windSpeed)) ?? "\(today.windSpeed) м/с"

humidityLabel.text = "\(today.humidity)%"

highlightDateLabel.text = "\(sunsetLabel.text ?? Self.timeFormatter.string(from: Date())), \(Self.highlightDateFormatter.string(from: today.date))"

} else {

minMaxLabel.text = "—/—"

sunriseLabel.text = "--:--"

sunsetLabel.text = "--:--"

precipitationLabel.text = "--"

windLabel.text = "-- м/с"

humidityLabel.text = "--%"

highlightDateLabel.text = nil

}

}

private func makeMetaStack(iconView: UIImageView, textLabel: UILabel) -> UIStackView {

let stack = UIStackView(arrangedSubviews: [iconView, textLabel])

stack.axis = .horizontal

stack.spacing = 4

stack.alignment = .center

stack.translatesAutoresizingMaskIntoConstraints = false

return stack

}

@objc private func showHourly() {

let controller = HourlyWeatherViewController(

hours: hoursData,

cityName: viewModel.cityName,

selectedDate: Date()

)

navigationController?.pushViewController(controller, animated: true)

}

@objc private func daysCountChanged() {

let count = UserDefaults.standard.integer(forKey: ForecastSettings.daysCountKey)

let daysCount = count == 0 ? ForecastSettings.defaultDaysCount : count

viewModel.setDisplayedDaysCount(daysCount)

}

private static let timeFormatter: DateFormatter = {

let formatter = DateFormatter()

formatter.locale = Locale(identifier: "ru_RU")

formatter.dateFormat = "HH:mm"

return formatter

}()

private static let highlightDateFormatter: DateFormatter = {

let formatter = DateFormatter()

formatter.locale = Locale(identifier: "ru_RU")

formatter.dateFormat = "E d MMMM"

return formatter

}()

private static let windFormatter: NumberFormatter = {

let formatter = NumberFormatter()

formatter.locale = Locale(identifier: "ru_RU")

formatter.maximumFractionDigits = 1

formatter.minimumFractionDigits = 0

formatter.positiveSuffix = " м/с"

return formatter

}()

guard

let cell = tableView.dequeueReusableCell(

withIdentifier: DailyWeatherCell.reuseID,

for: indexPath

) as? DailyWeatherCell

else {

return UITableViewCell()

}

cell.configure(with: daysData[indexPath.row], cityName: viewModel.cityName)

return cell

tableView.deselectRow(at: indexPath, animated: true)

let day = daysData[indexPath.row]

let controller = DailySummaryViewController(

day: day,

cityName: viewModel.cityName

)

navigationController?.pushViewController(controller, animated: true)

guard let cell = collectionView.dequeueReusableCell(

withReuseIdentifier: HourlyStripCell.reuseID,

for: indexPath

) as? HourlyStripCell else {

return UICollectionViewCell()

}

let item = stripHoursData[indexPath.item]

let isHighlighted = indexPath.item == 1

cell.configure(

time: Self.timeFormatter.string(from: item.date),

temperature: "\(item.temperature)°",

icon: DailyWeatherCell.icon(for: item.description),

highlighted: isHighlighted

)

return cell

_ collectionView: UICollectionView,

layout collectionViewLayout: UICollectionViewLayout,

sizeForItemAt indexPath: IndexPath

) -> CGSize {

CGSize(width: 42, height: 85)

static let reuseID = "HourlyStripCell"

private let pillView = UIView()

private let timeLabel = UILabel()

private let iconView = UIImageView()

private let temperatureLabel = UILabel()

override init(frame: CGRect) {

super.init(frame: frame)

setup()

}

required init?(coder: NSCoder) {

fatalError("init(coder:) has not been implemented")

}

func configure(time: String, temperature: String, icon: UIImage?, highlighted: Bool) {

timeLabel.text = time

temperatureLabel.text = temperature

iconView.image = icon

if highlighted {

pillView.backgroundColor = UIColor(red: 0.19, green: 0.47, blue: 1.00, alpha: 1)

pillView.layer.borderColor = UIColor.clear.cgColor

timeLabel.textColor = .white

temperatureLabel.textColor = .white

} else {

pillView.backgroundColor = .white

pillView.layer.borderColor = UIColor(red: 0.67, green: 0.74, blue: 0.92, alpha: 1).cgColor

timeLabel.textColor = UIColor(red: 0.20, green: 0.25, blue: 0.34, alpha: 1)

temperatureLabel.textColor = UIColor(red: 0.20, green: 0.25, blue: 0.34, alpha: 1)

}

}

private func setup() {

contentView.backgroundColor = .clear

pillView.translatesAutoresizingMaskIntoConstraints = false

pillView.layer.cornerRadius = 21

pillView.layer.cornerCurve = .continuous

pillView.layer.borderWidth = 0.5

pillView.clipsToBounds = true

timeLabel.font = .systemFont(ofSize: 14, weight: .medium)

timeLabel.textColor = UIColor(red: 0.20, green: 0.25, blue: 0.34, alpha: 1)

timeLabel.textAlignment = .center

timeLabel.translatesAutoresizingMaskIntoConstraints = false

iconView.tintColor = UIColor(red: 1.0, green: 0.87, blue: 0.09, alpha: 1)

iconView.contentMode = .scaleAspectFit

iconView.translatesAutoresizingMaskIntoConstraints = false

temperatureLabel.font = .systemFont(ofSize: 14, weight: .medium)

temperatureLabel.textColor = UIColor(red: 0.20, green: 0.25, blue: 0.34, alpha: 1)

temperatureLabel.textAlignment = .center

temperatureLabel.translatesAutoresizingMaskIntoConstraints = false

contentView.addSubview(pillView)

pillView.addSubview(timeLabel)

pillView.addSubview(iconView)

pillView.addSubview(temperatureLabel)

NSLayoutConstraint.activate([

pillView.topAnchor.constraint(equalTo: contentView.topAnchor),

pillView.leadingAnchor.constraint(equalTo: contentView.leadingAnchor),

pillView.trailingAnchor.constraint(equalTo: contentView.trailingAnchor),

pillView.bottomAnchor.constraint(equalTo: contentView.bottomAnchor),

timeLabel.topAnchor.constraint(equalTo: pillView.topAnchor, constant: 7),

timeLabel.leadingAnchor.constraint(equalTo: pillView.leadingAnchor),

timeLabel.trailingAnchor.constraint(equalTo: pillView.trailingAnchor),

iconView.topAnchor.constraint(equalTo: timeLabel.bottomAnchor, constant: 5),

iconView.centerXAnchor.constraint(equalTo: pillView.centerXAnchor),

iconView.widthAnchor.constraint(equalToConstant: 12),

iconView.heightAnchor.constraint(equalToConstant: 12),

temperatureLabel.topAnchor.constraint(equalTo: iconView.bottomAnchor, constant: 4),

temperatureLabel.leadingAnchor.constraint(equalTo: pillView.leadingAnchor),

temperatureLabel.trailingAnchor.constraint(equalTo: pillView.trailingAnchor),

temperatureLabel.bottomAnchor.constraint(lessThanOrEqualTo: pillView.bottomAnchor, constant: -6)

])

}

static let reuseID = "DailyWeatherCell"

private let dateLabel = UILabel()

private let conditionIconView = UIImageView()

private let precipitationLabel = UILabel()

private let cityLabel = UILabel()

private let titleLabel = UILabel()

private let tempLabel = UILabel()

private let chevronView = UIImageView(image: UIImage(systemName: "chevron.right"))

private let containerView = UIView()

override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {

super.init(style: style, reuseIdentifier: reuseIdentifier)

setup()

}

required init?(coder: NSCoder) {

fatalError("init(coder:) has not been implemented")

}

func configure(with day: DailyForecast, cityName: String) {

dateLabel.text = Self.dateFormatter.string(from: day.date)

cityLabel.text = cityName

titleLabel.text = day.description.capitalized

precipitationLabel.text = "\(day.precipitationProbability)%"

tempLabel.text = "\(day.minTemperature)°-\(day.maxTemperature)°"

conditionIconView.image = Self.icon(for: day.description)

}

private func setup() {

backgroundColor = .clear

contentView.backgroundColor = .clear

selectionStyle = .none

containerView.translatesAutoresizingMaskIntoConstraints = false

containerView.backgroundColor = WeatherTheme.dayListCard

containerView.layer.cornerRadius = 9

containerView.layer.cornerCurve = .continuous

containerView.layer.borderWidth = 1

containerView.layer.borderColor = WeatherTheme.dayListBorder.cgColor

containerView.layer.shadowColor = UIColor.black.cgColor

containerView.layer.shadowOpacity = 0.08

containerView.layer.shadowRadius = 6

containerView.layer.shadowOffset = CGSize(width: 0, height: 2)

containerView.layer.masksToBounds = false

contentView.addSubview(containerView)

dateLabel.font = .systemFont(ofSize: 15, weight: .regular)

dateLabel.textColor = WeatherTheme.mutedText

conditionIconView.translatesAutoresizingMaskIntoConstraints = false

conditionIconView.tintColor = WeatherTheme.precipitationText

conditionIconView.contentMode = .scaleAspectFit

precipitationLabel.font = .systemFont(ofSize: 15, weight: .semibold)

precipitationLabel.textColor = WeatherTheme.precipitationText

cityLabel.font = .systemFont(ofSize: 11, weight: .medium)

cityLabel.textColor = WeatherTheme.mutedText

cityLabel.lineBreakMode = .byTruncatingTail

cityLabel.translatesAutoresizingMaskIntoConstraints = false

titleLabel.font = .systemFont(ofSize: 17, weight: .medium)

titleLabel.textColor = WeatherTheme.darkText

titleLabel.setContentCompressionResistancePriority(.required, for: .horizontal)

titleLabel.lineBreakMode = .byTruncatingTail

titleLabel.translatesAutoresizingMaskIntoConstraints = false

tempLabel.font = .systemFont(ofSize: 17, weight: .semibold)

tempLabel.textColor = WeatherTheme.darkText

tempLabel.setContentCompressionResistancePriority(.defaultLow, for: .horizontal)

tempLabel.translatesAutoresizingMaskIntoConstraints = false

chevronView.translatesAutoresizingMaskIntoConstraints = false

chevronView.tintColor = WeatherTheme.darkText

chevronView.contentMode = .scaleAspectFit

let leftBottomRow = UIStackView(arrangedSubviews: [conditionIconView, precipitationLabel])

leftBottomRow.axis = .horizontal

leftBottomRow.spacing = 3

leftBottomRow.alignment = .center

leftBottomRow.translatesAutoresizingMaskIntoConstraints = false

let leftStack = UIStackView(arrangedSubviews: [dateLabel, leftBottomRow])

leftStack.axis = .vertical

leftStack.spacing = 0

leftStack.alignment = .leading

leftStack.translatesAutoresizingMaskIntoConstraints = false

containerView.addSubview(leftStack)

containerView.addSubview(cityLabel)

containerView.addSubview(titleLabel)

containerView.addSubview(tempLabel)

containerView.addSubview(chevronView)

NSLayoutConstraint.activate([

containerView.topAnchor.constraint(equalTo: contentView.topAnchor, constant: 5),

containerView.leadingAnchor.constraint(equalTo: contentView.leadingAnchor, constant: 16),

containerView.trailingAnchor.constraint(equalTo: contentView.trailingAnchor, constant: -16),

containerView.bottomAnchor.constraint(equalTo: contentView.bottomAnchor, constant: -5),

leftStack.leadingAnchor.constraint(equalTo: containerView.leadingAnchor, constant: 10),

leftStack.centerYAnchor.constraint(equalTo: containerView.centerYAnchor),

conditionIconView.widthAnchor.constraint(equalToConstant: 14),

conditionIconView.heightAnchor.constraint(equalToConstant: 14),

chevronView.trailingAnchor.constraint(equalTo: containerView.trailingAnchor, constant: -12),

chevronView.centerYAnchor.constraint(equalTo: containerView.centerYAnchor),

chevronView.widthAnchor.constraint(equalToConstant: 8),

chevronView.heightAnchor.constraint(equalToConstant: 12),

tempLabel.trailingAnchor.constraint(equalTo: chevronView.leadingAnchor, constant: -6),

tempLabel.centerYAnchor.constraint(equalTo: containerView.centerYAnchor),

cityLabel.leadingAnchor.constraint(equalTo: leftStack.trailingAnchor, constant: 8),

cityLabel.trailingAnchor.constraint(lessThanOrEqualTo: tempLabel.leadingAnchor, constant: -6),

cityLabel.bottomAnchor.constraint(equalTo: containerView.centerYAnchor, constant: -1),

titleLabel.leadingAnchor.constraint(equalTo: leftStack.trailingAnchor, constant: 8),

titleLabel.topAnchor.constraint(equalTo: cityLabel.bottomAnchor, constant: 1),

titleLabel.trailingAnchor.constraint(lessThanOrEqualTo: tempLabel.leadingAnchor, constant: -6)

])

}

private static let dateFormatter: DateFormatter = {

let formatter = DateFormatter()

formatter.locale = Locale(identifier: "ru_RU")

formatter.dateFormat = "dd/MM"

return formatter

}()

static func icon(for description: String) -> UIImage? {

let normalized = description.lowercased()

let symbol: String

if normalized.contains("лив") || normalized.contains("дожд") {

symbol = "cloud.rain.fill"

} else if normalized.contains("снег") {

symbol = "cloud.snow.fill"

} else if normalized.contains("гроз") {

symbol = "cloud.bolt.rain.fill"

} else if normalized.contains("облач") {

symbol = "cloud.fill"

} else {

symbol = "sun.max.fill"

}

return UIImage(systemName: symbol)

}

private let day: DailyForecast

private let cityName: String

private let gradientLayer = CAGradientLayer()

private let scrollView = UIScrollView()

private let contentStack = UIStackView()

init(day: DailyForecast, cityName: String) {

self.day = day

self.cityName = cityName

super.init(nibName: nil, bundle: nil)

}

required init?(coder: NSCoder) {

fatalError("init(coder:) has not been implemented")

}

override func viewDidLoad() {

super.viewDidLoad()

title = "Дневная сводка"

setupBackground()

setupLayout()

buildContent()

}

override func viewDidLayoutSubviews() {

super.viewDidLayoutSubviews()